1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package net.sourceforge.pmd.lang.plsql.ast;
21
22 import java.io.*;
23 import net.sourceforge.pmd.lang.ast.Node;
24 import net.sourceforge.pmd.lang.ast.SimpleCharStream;
25 import net.sourceforge.pmd.lang.ast.TokenMgrError;
26
27 public class PLSQLParserimplements PLSQLParserTreeConstants, PLSQLParserConstants {
28 protected JJTPLSQLParserState jjtree = new JJTPLSQLParserState();
29
30
31
32
33 public static void main(String[] args)
34 throws ParseException {
35
36 PLSQLParser parser = new PLSQLParser(System.in);
37 PLSQLNode node = parser.Input();
38
39 String s;
40 s = "qwerty";
41
42 s = "\u005c"qwerty\u005c"";
43
44 s = "\u005c"qwerty\u005c".uiop";
45
46 s = "\u005c"qwerty\u005c".\u005c"uiop\u005c"";
47
48 }
49
50
51
52
53 public static String canonicalName(String name)
54 {
55 StringBuilder s = null ;
56
57
58 if (null == name) {
59 return name;
60 }
61 else if (-1 == name.indexOf('"') )
62 {
63 name = name.toUpperCase();
64 s = new StringBuilder(name.trim());
65 }
66 else
67 {
68 StringBuilder oldString = new StringBuilder( name.trim().length());
69 s = new StringBuilder(name.trim());
70 boolean quotedCharacter = false ;
71 for (int i=0; i<oldString.length(); i++) {
72 if (oldString.charAt(i) == '"')
73 {
74
75 oldString.deleteCharAt(i);
76 i--;
77
78
79 quotedCharacter = !quotedCharacter ;
80 }
81 else
82 {
83 s.append( quotedCharacter
84 ? s.charAt(i)
85 : Character.toUpperCase(s.charAt(i))
86 );
87 }
88 }
89 }
90 return s.toString();
91 }
92
93
94
95
96
97
98
99
100
101
102
103 final public ASTInput Input() throws ParseException {
104
105 ASTInput jjtn000 = new ASTInput(this, JJTINPUT);
106 boolean jjtc000 = true;
107 jjtree.openNodeScope(jjtn000);
108 try {
109 label_1:
110 while (true) {
111 switch (jj_nt.kind) {
112 case 2:
113 case 3:
114 case 21:
115 case ALTER:
116 case BEGIN:
117 case COLUMN:
118 case COMMENT:
119 case COMMIT:
120 case CONNECT:
121 case CREATE:
122 case DECLARE:
123 case DELETE:
124 case DROP:
125 case EXECUTE:
126 case EXIT:
127 case FUNCTION:
128 case GRANT:
129 case INSERT:
130 case LOCK:
131 case MERGE:
132 case PACKAGE:
133 case PROMPT:
134 case PROCEDURE:
135 case RENAME:
136 case REVOKE:
137 case ROLLBACK:
138 case SAVEPOINT:
139 case SELECT:
140 case SET:
141 case START:
142 case TRIGGER:
143 case TYPE:
144 case SHOW:
145 case SPOOL:
146 case UPDATE:
147 case WITH:
148 case ANALYZE:
149 case ASSOCIATE:
150 case AUDIT:
151 case DDL:
152 case DISASSOCIATE:
153 case NOAUDIT:
154 case TRUNCATE:
155 case ACCEPT:
156 case COPY:
157 case DEFINE:
158 case DISCONNECT:
159 case HOST:
160 case PRINT:
161 case QUIT:
162 case REMARK:
163 case UNDEFINE:
164 case VARIABLE:
165 case WHENEVER:
166 case IDENTIFIER:
167 ;
168 break;
169 default:
170 jj_la1[0] = jj_gen;
171 break label_1;
172 }
173 if (jj_2_1(7)) {
174 PackageSpecification();
175 } else if (jj_2_2(7)) {
176 PackageBody();
177 } else if (jj_2_3(6)) {
178 TypeSpecification();
179 } else if (jj_2_4(6)) {
180 Table();
181 } else if (jj_2_5(6)) {
182 View();
183 } else if (jj_2_6(6)) {
184 TriggerUnit();
185 } else if (jj_2_7(6)) {
186 AlterTrigger();
187 } else if (jj_2_8(6)) {
188 Synonym();
189 } else if (jj_2_9(6)) {
190 Directory();
191 } else if (jj_2_10(6)) {
192 DatabaseLink();
193 } else if (jj_2_11(6)) {
194 Global();
195 } else if (jj_2_12(6)) {
196 DDLCommand();
197 } else if (jj_2_13(2)) {
198 SqlPlusCommand();
199 } else {
200 switch (jj_nt.kind) {
201 case COMMIT:
202 case DELETE:
203 case INSERT:
204 case LOCK:
205 case MERGE:
206 case ROLLBACK:
207 case SAVEPOINT:
208 case SELECT:
209 case UPDATE:
210 case WITH:
211 switch (jj_nt.kind) {
212 case SELECT:
213 jj_consume_token(SELECT);
214 break;
215 case UPDATE:
216 jj_consume_token(UPDATE);
217 break;
218 case INSERT:
219 jj_consume_token(INSERT);
220 break;
221 case DELETE:
222 jj_consume_token(DELETE);
223 break;
224 case COMMIT:
225 jj_consume_token(COMMIT);
226 break;
227 case ROLLBACK:
228 jj_consume_token(ROLLBACK);
229 break;
230 case SAVEPOINT:
231 jj_consume_token(SAVEPOINT);
232 break;
233 case LOCK:
234 jj_consume_token(LOCK);
235 jj_consume_token(TABLE);
236 break;
237 case MERGE:
238 jj_consume_token(MERGE);
239 break;
240 case WITH:
241 jj_consume_token(WITH);
242 break;
243 default:
244 jj_la1[1] = jj_gen;
245 jj_consume_token(-1);
246 throw new ParseException();
247 }
248 SkipPastNextTokenOccurrence(SQLPLUS_TERMINATOR);
249 break;
250 default:
251 jj_la1[2] = jj_gen;
252 jj_consume_token(-1);
253 throw new ParseException();
254 }
255 }
256 label_2:
257 while (true) {
258 switch (jj_nt.kind) {
259 case 1:
260 ;
261 break;
262 default:
263 jj_la1[3] = jj_gen;
264 break label_2;
265 }
266 jj_consume_token(1);
267 }
268 }
269 jj_consume_token(0);
270 jjtree.closeNodeScope(jjtn000, true);
271 jjtc000 = false;
272 {if (true) return jjtn000 ;}
273 } catch (Throwable jjte000) {
274 if (jjtc000) {
275 jjtree.clearNodeScope(jjtn000);
276 jjtc000 = false;
277 } else {
278 jjtree.popNode();
279 }
280 if (jjte000 instanceof RuntimeException) {
281 {if (true) throw (RuntimeException)jjte000;}
282 }
283 if (jjte000 instanceof ParseException) {
284 {if (true) throw (ParseException)jjte000;}
285 }
286 {if (true) throw (Error)jjte000;}
287 } finally {
288 if (jjtc000) {
289 jjtree.closeNodeScope(jjtn000, true);
290 }
291 }
292 throw new Error("Missing return statement in function");
293 }
294
295 final public ASTDDLCommand DDLCommand() throws ParseException {
296
297 ASTDDLCommand jjtn000 = new ASTDDLCommand(this, JJTDDLCOMMAND);
298 boolean jjtc000 = true;
299 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
300 try {
301 simpleNode = DDLEvent();
302 SkipPastNextTokenOccurrence(SQLPLUS_TERMINATOR);
303 jjtree.closeNodeScope(jjtn000, true);
304 jjtc000 = false;
305 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
306 } catch (Throwable jjte000) {
307 if (jjtc000) {
308 jjtree.clearNodeScope(jjtn000);
309 jjtc000 = false;
310 } else {
311 jjtree.popNode();
312 }
313 if (jjte000 instanceof RuntimeException) {
314 {if (true) throw (RuntimeException)jjte000;}
315 }
316 if (jjte000 instanceof ParseException) {
317 {if (true) throw (ParseException)jjte000;}
318 }
319 {if (true) throw (Error)jjte000;}
320 } finally {
321 if (jjtc000) {
322 jjtree.closeNodeScope(jjtn000, true);
323 }
324 }
325 throw new Error("Missing return statement in function");
326 }
327
328 final public ASTSqlPlusCommand SqlPlusCommand() throws ParseException {
329
330 ASTSqlPlusCommand jjtn000 = new ASTSqlPlusCommand(this, JJTSQLPLUSCOMMAND);
331 boolean jjtc000 = true;
332 jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder() ;
333 try {
334 switch (jj_nt.kind) {
335 case 2:
336 jj_consume_token(2);
337 break;
338 case ACCEPT:
339 jj_consume_token(ACCEPT);
340 break;
341 case COLUMN:
342 jj_consume_token(COLUMN);
343 break;
344 case CONNECT:
345 jj_consume_token(CONNECT);
346 break;
347 case COPY:
348 jj_consume_token(COPY);
349 break;
350 case DEFINE:
351 jj_consume_token(DEFINE);
352 break;
353 case DISCONNECT:
354 jj_consume_token(DISCONNECT);
355 break;
356 case EXECUTE:
357 jj_consume_token(EXECUTE);
358 break;
359 case EXIT:
360 jj_consume_token(EXIT);
361 break;
362 case HOST:
363 jj_consume_token(HOST);
364 break;
365 case PRINT:
366 jj_consume_token(PRINT);
367 break;
368 case PROMPT:
369 jj_consume_token(PROMPT);
370 break;
371 case QUIT:
372 jj_consume_token(QUIT);
373 break;
374 case REMARK:
375 jj_consume_token(REMARK);
376 break;
377 case SET:
378 jj_consume_token(SET);
379 break;
380 case SHOW:
381 jj_consume_token(SHOW);
382 break;
383 case SPOOL:
384 jj_consume_token(SPOOL);
385 break;
386 case START:
387 jj_consume_token(START);
388 break;
389 case UNDEFINE:
390 jj_consume_token(UNDEFINE);
391 break;
392 case VARIABLE:
393 jj_consume_token(VARIABLE);
394 break;
395 case WHENEVER:
396 jj_consume_token(WHENEVER);
397 break;
398 case COMMENT:
399 jj_consume_token(COMMENT);
400 break;
401 case GRANT:
402 jj_consume_token(GRANT);
403 break;
404 case REVOKE:
405 jj_consume_token(REVOKE);
406 break;
407 case DROP:
408 jj_consume_token(DROP);
409 break;
410 case IDENTIFIER:
411 jj_consume_token(IDENTIFIER);
412 break;
413 case 3:
414 jj_consume_token(3);
415 jj_consume_token(ATTACH);
416 break;
417 default:
418 jj_la1[4] = jj_gen;
419 jj_consume_token(-1);
420 throw new ParseException();
421 }
422 sb.append(token.image) ; sb.append(" ...") ;
423 Skip2NextTokenOccurrence(EOL);
424 jjtree.closeNodeScope(jjtn000, true);
425 jjtc000 = false;
426 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
427 } catch (Throwable jjte000) {
428 if (jjtc000) {
429 jjtree.clearNodeScope(jjtn000);
430 jjtc000 = false;
431 } else {
432 jjtree.popNode();
433 }
434 if (jjte000 instanceof RuntimeException) {
435 {if (true) throw (RuntimeException)jjte000;}
436 }
437 if (jjte000 instanceof ParseException) {
438 {if (true) throw (ParseException)jjte000;}
439 }
440 {if (true) throw (Error)jjte000;}
441 } finally {
442 if (jjtc000) {
443 jjtree.closeNodeScope(jjtn000, true);
444 }
445 }
446 throw new Error("Missing return statement in function");
447 }
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474 final public ASTGlobal Global() throws ParseException {
475
476 ASTGlobal jjtn000 = new ASTGlobal(this, JJTGLOBAL);
477 boolean jjtc000 = true;
478 jjtree.openNodeScope(jjtn000);
479 try {
480 if (jj_2_14(2147483647)) {
481 label_3:
482 while (true) {
483 switch (jj_nt.kind) {
484 case 21:
485 ;
486 break;
487 default:
488 jj_la1[5] = jj_gen;
489 break label_3;
490 }
491 Label();
492 }
493 Block();
494 jj_consume_token(4);
495 } else if (jj_2_15(4)) {
496 ProgramUnit();
497 } else {
498 jj_consume_token(-1);
499 throw new ParseException();
500 }
501 jjtree.closeNodeScope(jjtn000, true);
502 jjtc000 = false;
503 {if (true) return jjtn000 ;}
504 } catch (Throwable jjte000) {
505 if (jjtc000) {
506 jjtree.clearNodeScope(jjtn000);
507 jjtc000 = false;
508 } else {
509 jjtree.popNode();
510 }
511 if (jjte000 instanceof RuntimeException) {
512 {if (true) throw (RuntimeException)jjte000;}
513 }
514 if (jjte000 instanceof ParseException) {
515 {if (true) throw (ParseException)jjte000;}
516 }
517 {if (true) throw (Error)jjte000;}
518 } finally {
519 if (jjtc000) {
520 jjtree.closeNodeScope(jjtn000, true);
521 }
522 }
523 throw new Error("Missing return statement in function");
524 }
525
526 final public ASTBlock Block() throws ParseException {
527
528 ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);
529 boolean jjtc000 = true;
530 jjtree.openNodeScope(jjtn000);
531 try {
532 switch (jj_nt.kind) {
533 case DECLARE:
534 jj_consume_token(DECLARE);
535 DeclarativeSection();
536 break;
537 default:
538 jj_la1[6] = jj_gen;
539 ;
540 }
541 jj_consume_token(BEGIN);
542 label_4:
543 while (true) {
544 switch (jj_nt.kind) {
545 case 5:
546 case 16:
547 case 17:
548 case 21:
549 case REPLACE:
550 case DEFINER:
551 case CURRENT_USER:
552 case LANGUAGE:
553 case INLINE:
554 case ADD:
555 case AGGREGATE:
556 case ARRAY:
557 case AT:
558 case ATTRIBUTE:
559 case AUTHID:
560 case BEGIN:
561 case BODY:
562 case BULK:
563 case BYTE:
564 case CASCADE:
565 case CASE:
566 case CLOSE:
567 case COALESCE:
568 case COLLECT:
569 case COLUMN:
570 case COMMENT:
571 case COMMIT:
572 case CONSTRUCTOR:
573 case CONTINUE:
574 case CONVERT:
575 case CURRENT:
576 case CURSOR:
577 case DATA:
578 case DATE:
579 case DAY:
580 case DECLARE:
581 case DELETE:
582 case DISABLE:
583 case EDITIONABLE:
584 case ELEMENT:
585 case ENABLE:
586 case ESCAPE:
587 case EXCEPT:
588 case EXCEPTIONS:
589 case EXECUTE:
590 case EXIT:
591 case EXTERNAL:
592 case EXTENDS:
593 case EXTRACT:
594 case FALSE:
595 case FETCH:
596 case FINAL:
597 case FOR:
598 case FORALL:
599 case FORCE:
600 case FUNCTION:
601 case GLOBAL:
602 case GOTO:
603 case HASH:
604 case HEAP:
605 case HOUR:
606 case IF:
607 case IMMEDIATE:
608 case INDICES:
609 case INDEXTYPE:
610 case INDICATOR:
611 case INSERT:
612 case INSTANTIABLE:
613 case INTERVAL:
614 case INVALIDATE:
615 case ISOLATION:
616 case JAVA:
617 case LEVEL:
618 case LIMIT:
619 case LOCK:
620 case LOOP:
621 case MAP:
622 case MAX:
623 case MEMBER:
624 case MERGE:
625 case MIN:
626 case MINUTE:
627 case MLSLABEL:
628 case MODIFY:
629 case MOD:
630 case MONTH:
631 case NATURAL:
632 case NEW:
633 case NEW_DOT:
634 case NO:
635 case NONEDITIONABLE:
636 case NOT:
637 case NULL:
638 case NULLIF:
639 case OBJECT:
640 case OID:
641 case OPAQUE:
642 case OPEN:
643 case OPERATOR:
644 case ORGANIZATION:
645 case OTHERS:
646 case OVERRIDING:
647 case PACKAGE:
648 case PARTITION:
649 case PIPE:
650 case PRAGMA:
651 case PRESERVE:
652 case PRIVATE:
653 case PROCEDURE:
654 case RAISE:
655 case RANGE:
656 case RAW:
657 case REAL:
658 case RECORD:
659 case REF:
660 case RELEASE:
661 case RELIES_ON:
662 case RENAME:
663 case RESULT:
664 case RETURN:
665 case RETURNING:
666 case REVERSE:
667 case ROLLBACK:
668 case ROW:
669 case ROWS:
670 case ROWID:
671 case ROWNUM:
672 case SAVE:
673 case SAVEPOINT:
674 case SECOND:
675 case SELECT:
676 case SELF:
677 case SET:
678 case SPACE:
679 case SQL:
680 case SQLCODE:
681 case SQLERRM:
682 case STATIC:
683 case SUBTYPE:
684 case SUBSTITUTABLE:
685 case SUCCESSFUL:
686 case SYSDATE:
687 case SYS_REFCURSOR:
688 case TEMPORARY:
689 case TIME:
690 case TIMESTAMP:
691 case TIMEZONE_REGION:
692 case TIMEZONE_ABBR:
693 case TIMEZONE_MINUTE:
694 case TIMEZONE_HOUR:
695 case TRANSACTION:
696 case TRUE:
697 case TYPE:
698 case UNDER:
699 case USING:
700 case WHILE:
701 case YES:
702 case SHOW:
703 case A:
704 case UPDATE:
705 case DOUBLE:
706 case DEC:
707 case PRECISION:
708 case INT:
709 case NUMERIC:
710 case NCHAR:
711 case NVARCHAR2:
712 case STRING:
713 case UROWID:
714 case VARRAY:
715 case VARYING:
716 case BFILE:
717 case BLOB:
718 case CLOB:
719 case NCLOB:
720 case YEAR:
721 case LOCAL:
722 case WITH:
723 case ZONE:
724 case CHARACTER:
725 case AFTER:
726 case BEFORE:
727 case OLD:
728 case PARENT:
729 case CC_IF:
730 case CC_ERROR:
731 case ANALYZE:
732 case ASSOCIATE:
733 case AUDIT:
734 case COMPOUND:
735 case DATABASE:
736 case CALL:
737 case DDL:
738 case DISASSOCIATE:
739 case EACH:
740 case FOLLOWS:
741 case LOGOFF:
742 case LOGON:
743 case NESTED:
744 case NOAUDIT:
745 case SCHEMA:
746 case SERVERERROR:
747 case SHUTDOWN:
748 case STARTUP:
749 case STATEMENT:
750 case STATISTICS:
751 case SUSPEND:
752 case TRUNCATE:
753 case WRAPPED:
754 case LIBRARY:
755 case NAME:
756 case STRUCT:
757 case CONTEXT:
758 case PARAMETERS:
759 case LENGTH:
760 case TDO:
761 case MAXLEN:
762 case CHARSETID:
763 case CHARSETFORM:
764 case ACCEPT:
765 case ACCESSIBLE:
766 case COPY:
767 case DEFINE:
768 case DISCONNECT:
769 case HOST:
770 case PRINT:
771 case QUIT:
772 case REMARK:
773 case UNDEFINE:
774 case VARIABLE:
775 case WHENEVER:
776 case ATTACH:
777 case CAST:
778 case TREAT:
779 case TRIM:
780 case LEFT:
781 case RIGHT:
782 case BOTH:
783 case EMPTY:
784 case MULTISET:
785 case SUBMULTISET:
786 case LEADING:
787 case TRAILING:
788 case CHAR_CS:
789 case NCHAR_CS:
790 case DBTIMEZONE:
791 case SESSIONTIMEZONE:
792 case AUTHENTICATED:
793 case LINK:
794 case SHARED:
795 case DIRECTORY:
796 case USER:
797 case IDENTIFIER:
798 case UNSIGNED_NUMERIC_LITERAL:
799 case CHARACTER_LITERAL:
800 case STRING_LITERAL:
801 case QUOTED_LITERAL:
802 ;
803 break;
804 default:
805 jj_la1[7] = jj_gen;
806 break label_4;
807 }
808 Statement();
809 }
810 switch (jj_nt.kind) {
811 case EXCEPTION:
812 ExceptionHandler();
813 break;
814 default:
815 jj_la1[8] = jj_gen;
816 ;
817 }
818 jj_consume_token(END);
819 switch (jj_nt.kind) {
820 case IDENTIFIER:
821 jj_consume_token(IDENTIFIER);
822 break;
823 default:
824 jj_la1[9] = jj_gen;
825 ;
826 }
827 jjtree.closeNodeScope(jjtn000, true);
828 jjtc000 = false;
829 {if (true) return jjtn000 ;}
830 } catch (Throwable jjte000) {
831 if (jjtc000) {
832 jjtree.clearNodeScope(jjtn000);
833 jjtc000 = false;
834 } else {
835 jjtree.popNode();
836 }
837 if (jjte000 instanceof RuntimeException) {
838 {if (true) throw (RuntimeException)jjte000;}
839 }
840 if (jjte000 instanceof ParseException) {
841 {if (true) throw (ParseException)jjte000;}
842 }
843 {if (true) throw (Error)jjte000;}
844 } finally {
845 if (jjtc000) {
846 jjtree.closeNodeScope(jjtn000, true);
847 }
848 }
849 throw new Error("Missing return statement in function");
850 }
851
852 final public ASTPackageSpecification PackageSpecification() throws ParseException {
853
854 ASTPackageSpecification jjtn000 = new ASTPackageSpecification(this, JJTPACKAGESPECIFICATION);
855 boolean jjtc000 = true;
856 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
857 try {
858 switch (jj_nt.kind) {
859 case CREATE:
860 jj_consume_token(CREATE);
861 switch (jj_nt.kind) {
862 case OR:
863 jj_consume_token(OR);
864 jj_consume_token(REPLACE);
865 break;
866 default:
867 jj_la1[10] = jj_gen;
868 ;
869 }
870 switch (jj_nt.kind) {
871 case EDITIONABLE:
872 case NONEDITIONABLE:
873 switch (jj_nt.kind) {
874 case EDITIONABLE:
875 jj_consume_token(EDITIONABLE);
876 break;
877 case NONEDITIONABLE:
878 jj_consume_token(NONEDITIONABLE);
879 break;
880 default:
881 jj_la1[11] = jj_gen;
882 jj_consume_token(-1);
883 throw new ParseException();
884 }
885 break;
886 default:
887 jj_la1[12] = jj_gen;
888 ;
889 }
890 break;
891 default:
892 jj_la1[13] = jj_gen;
893 ;
894 }
895 jj_consume_token(PACKAGE);
896 simpleNode = ObjectNameDeclaration();
897 label_5:
898 while (true) {
899 switch (jj_nt.kind) {
900 case AUTHID:
901 case ACCESSIBLE:
902 ;
903 break;
904 default:
905 jj_la1[14] = jj_gen;
906 break label_5;
907 }
908 switch (jj_nt.kind) {
909 case AUTHID:
910 jj_consume_token(AUTHID);
911 switch (jj_nt.kind) {
912 case CURRENT_USER:
913 jj_consume_token(CURRENT_USER);
914 break;
915 case DEFINER:
916 jj_consume_token(DEFINER);
917 break;
918 default:
919 jj_la1[15] = jj_gen;
920 jj_consume_token(-1);
921 throw new ParseException();
922 }
923 break;
924 case ACCESSIBLE:
925 AccessibleByClause();
926 break;
927 default:
928 jj_la1[16] = jj_gen;
929 jj_consume_token(-1);
930 throw new ParseException();
931 }
932 }
933 switch (jj_nt.kind) {
934 case WRAPPED:
935 WrappedObject();
936 break;
937 case AS:
938 case IS:
939 switch (jj_nt.kind) {
940 case IS:
941 jj_consume_token(IS);
942 break;
943 case AS:
944 jj_consume_token(AS);
945 break;
946 default:
947 jj_la1[17] = jj_gen;
948 jj_consume_token(-1);
949 throw new ParseException();
950 }
951 DeclarativeSection();
952 jj_consume_token(END);
953 switch (jj_nt.kind) {
954 case REPLACE:
955 case DEFINER:
956 case CURRENT_USER:
957 case SERIALLY_REUSABLE:
958 case RESTRICT_REFERENCES:
959 case EXCEPTION_INIT:
960 case AUTONOMOUS_TRANSACTION:
961 case LANGUAGE:
962 case INLINE:
963 case ADD:
964 case AGGREGATE:
965 case ALL:
966 case ALTER:
967 case AND:
968 case ANY:
969 case ARRAY:
970 case AS:
971 case ASC:
972 case AT:
973 case ATTRIBUTE:
974 case AUTHID:
975 case AVG:
976 case BETWEEN:
977 case BINARY_INTEGER:
978 case BODY:
979 case BOOLEAN:
980 case BULK:
981 case BY:
982 case BYTE:
983 case CASCADE:
984 case CASE:
985 case CHAR:
986 case CHAR_BASE:
987 case CHECK:
988 case CLOSE:
989 case CLUSTER:
990 case COALESCE:
991 case COLLECT:
992 case COLUMN:
993 case COMMENT:
994 case COMMIT:
995 case COMPRESS:
996 case CONNECT:
997 case CONSTANT:
998 case CONSTRUCTOR:
999 case CONTINUE:
1000 case CONVERT:
1001 case CREATE:
1002 case CURRENT:
1003 case CURRVAL:
1004 case CURSOR:
1005 case DATA:
1006 case DATE:
1007 case DAY:
1008 case DECLARE:
1009 case DECIMAL:
1010 case _DEFAULT:
1011 case DELETE:
1012 case DESC:
1013 case DISABLE:
1014 case DISTINCT:
1015 case DO:
1016 case DROP:
1017 case EDITIONABLE:
1018 case ELEMENT:
1019 case ELSE:
1020 case ELSIF:
1021 case ENABLE:
1022 case ESCAPE:
1023 case EXCEPT:
1024 case EXCEPTION:
1025 case EXCEPTIONS:
1026 case EXCLUSIVE:
1027 case EXECUTE:
1028 case EXISTS:
1029 case EXIT:
1030 case EXTERNAL:
1031 case EXTENDS:
1032 case EXTRACT:
1033 case FALSE:
1034 case FETCH:
1035 case FINAL:
1036 case FLOAT:
1037 case FOR:
1038 case FORALL:
1039 case FORCE:
1040 case FROM:
1041 case FUNCTION:
1042 case GLOBAL:
1043 case GOTO:
1044 case GROUP:
1045 case HASH:
1046 case HAVING:
1047 case HEAP:
1048 case HOUR:
1049 case IF:
1050 case IMMEDIATE:
1051 case IN:
1052 case INDEX:
1053 case INDICES:
1054 case INDEXTYPE:
1055 case INDICATOR:
1056 case INSERT:
1057 case INSTANTIABLE:
1058 case INTEGER:
1059 case INTERFACE:
1060 case INTERSECT:
1061 case INTERVAL:
1062 case INTO:
1063 case INVALIDATE:
1064 case IS:
1065 case ISOLATION:
1066 case JAVA:
1067 case LEVEL:
1068 case LIKE:
1069 case LIMIT:
1070 case LIMITED:
1071 case LOCK:
1072 case LONG:
1073 case LOOP:
1074 case MAP:
1075 case MAX:
1076 case MEMBER:
1077 case MERGE:
1078 case MIN:
1079 case MINUS:
1080 case MINUTE:
1081 case MLSLABEL:
1082 case MODIFY:
1083 case MOD:
1084 case MODE:
1085 case MONTH:
1086 case NATURAL:
1087 case NATURALN:
1088 case NEW:
1089 case NEXTVAL:
1090 case NO:
1091 case NOCOPY:
1092 case NONEDITIONABLE:
1093 case NOT:
1094 case NOWAIT:
1095 case NULL:
1096 case NULLIF:
1097 case NUMBER:
1098 case BFILE_BASE:
1099 case BLOB_BASE:
1100 case CLOB_BASE:
1101 case DATE_BASE:
1102 case NUMBER_BASE:
1103 case OBJECT:
1104 case OCIROWID:
1105 case OF:
1106 case OID:
1107 case ON:
1108 case OPAQUE:
1109 case OPEN:
1110 case OPERATOR:
1111 case OPTION:
1112 case OR:
1113 case ORDER:
1114 case ORGANIZATION:
1115 case OTHERS:
1116 case OUT:
1117 case OVERRIDING:
1118 case PACKAGE:
1119 case PARTITION:
1120 case PCTFREE:
1121 case PLS_INTEGER:
1122 case POSITIVE:
1123 case POSITIVEN:
1124 case PRESERVE:
1125 case PRIOR:
1126 case PROMPT:
1127 case PRIVATE:
1128 case PROCEDURE:
1129 case PUBLIC:
1130 case RAISE:
1131 case RANGE:
1132 case RAW:
1133 case REAL:
1134 case RECORD:
1135 case REF:
1136 case RELEASE:
1137 case RELIES_ON:
1138 case RENAME:
1139 case RESULT:
1140 case RETURN:
1141 case RETURNING:
1142 case REVERSE:
1143 case ROLLBACK:
1144 case ROW:
1145 case ROWS:
1146 case ROWID:
1147 case ROWNUM:
1148 case ROWTYPE:
1149 case SAVE:
1150 case SAVEPOINT:
1151 case SECOND:
1152 case SELECT:
1153 case SELF:
1154 case SEPARATE:
1155 case SET:
1156 case SHARE:
1157 case SMALLINT:
1158 case SPACE:
1159 case SQL:
1160 case SQLCODE:
1161 case SQLERRM:
1162 case START:
1163 case STATIC:
1164 case STDDEV:
1165 case SUBTYPE:
1166 case SUBSTITUTABLE:
1167 case SUCCESSFUL:
1168 case SUM:
1169 case SYNONYM:
1170 case SYSDATE:
1171 case SYS_REFCURSOR:
1172 case TABLE:
1173 case TEMPORARY:
1174 case THEN:
1175 case TIME:
1176 case TIMESTAMP:
1177 case TIMEZONE_REGION:
1178 case TIMEZONE_ABBR:
1179 case TIMEZONE_MINUTE:
1180 case TIMEZONE_HOUR:
1181 case TO:
1182 case TRANSACTION:
1183 case TRIGGER:
1184 case TRUE:
1185 case TYPE:
1186 case UI:
1187 case UNDER:
1188 case USING:
1189 case WHILE:
1190 case YES:
1191 case SHOW:
1192 case A:
1193 case UPDATE:
1194 case VARCHAR:
1195 case VARCHAR2:
1196 case DOUBLE:
1197 case DEC:
1198 case PRECISION:
1199 case INT:
1200 case NUMERIC:
1201 case SIGNTYPE:
1202 case NCHAR:
1203 case NVARCHAR2:
1204 case STRING:
1205 case UROWID:
1206 case VARRAY:
1207 case VARYING:
1208 case BFILE:
1209 case BLOB:
1210 case CLOB:
1211 case NCLOB:
1212 case YEAR:
1213 case LOCAL:
1214 case WITH:
1215 case ZONE:
1216 case CHARACTER:
1217 case AFTER:
1218 case BEFORE:
1219 case OLD:
1220 case PARENT:
1221 case ANALYZE:
1222 case ASSOCIATE:
1223 case AUDIT:
1224 case COMPOUND:
1225 case DATABASE:
1226 case CALL:
1227 case DDL:
1228 case DISASSOCIATE:
1229 case EACH:
1230 case FOLLOWS:
1231 case LOGOFF:
1232 case LOGON:
1233 case NESTED:
1234 case NOAUDIT:
1235 case SCHEMA:
1236 case SERVERERROR:
1237 case SHUTDOWN:
1238 case STARTUP:
1239 case STATEMENT:
1240 case STATISTICS:
1241 case SUSPEND:
1242 case TRUNCATE:
1243 case WRAPPED:
1244 case LIBRARY:
1245 case NAME:
1246 case STRUCT:
1247 case CONTEXT:
1248 case PARAMETERS:
1249 case LENGTH:
1250 case TDO:
1251 case MAXLEN:
1252 case CHARSETID:
1253 case CHARSETFORM:
1254 case ACCEPT:
1255 case ACCESSIBLE:
1256 case COPY:
1257 case DEFINE:
1258 case DISCONNECT:
1259 case HOST:
1260 case PRINT:
1261 case QUIT:
1262 case REMARK:
1263 case UNDEFINE:
1264 case VARIABLE:
1265 case WHENEVER:
1266 case ATTACH:
1267 case CAST:
1268 case TREAT:
1269 case TRIM:
1270 case LEFT:
1271 case RIGHT:
1272 case BOTH:
1273 case EMPTY:
1274 case MULTISET:
1275 case SUBMULTISET:
1276 case LEADING:
1277 case TRAILING:
1278 case CHAR_CS:
1279 case NCHAR_CS:
1280 case DBTIMEZONE:
1281 case SESSIONTIMEZONE:
1282 case AUTHENTICATED:
1283 case LINK:
1284 case SHARED:
1285 case DIRECTORY:
1286 case USER:
1287 case IDENTIFIER:
1288 case QUOTED_LITERAL:
1289 case SQLDATA_CLASS:
1290 case CUSTOMDATUM_CLASS:
1291 case ORADATA_CLASS:
1292 case JAVA_INTERFACE_CLASS:
1293 ID();
1294 break;
1295 default:
1296 jj_la1[18] = jj_gen;
1297 ;
1298 }
1299 jj_consume_token(4);
1300 break;
1301 default:
1302 jj_la1[19] = jj_gen;
1303 jj_consume_token(-1);
1304 throw new ParseException();
1305 }
1306 jjtree.closeNodeScope(jjtn000, true);
1307 jjtc000 = false;
1308 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
1309 } catch (Throwable jjte000) {
1310 if (jjtc000) {
1311 jjtree.clearNodeScope(jjtn000);
1312 jjtc000 = false;
1313 } else {
1314 jjtree.popNode();
1315 }
1316 if (jjte000 instanceof RuntimeException) {
1317 {if (true) throw (RuntimeException)jjte000;}
1318 }
1319 if (jjte000 instanceof ParseException) {
1320 {if (true) throw (ParseException)jjte000;}
1321 }
1322 {if (true) throw (Error)jjte000;}
1323 } finally {
1324 if (jjtc000) {
1325 jjtree.closeNodeScope(jjtn000, true);
1326 }
1327 }
1328 throw new Error("Missing return statement in function");
1329 }
1330
1331 final public ASTPackageBody PackageBody() throws ParseException {
1332
1333 ASTPackageBody jjtn000 = new ASTPackageBody(this, JJTPACKAGEBODY);
1334 boolean jjtc000 = true;
1335 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
1336 try {
1337 switch (jj_nt.kind) {
1338 case CREATE:
1339 jj_consume_token(CREATE);
1340 switch (jj_nt.kind) {
1341 case OR:
1342 jj_consume_token(OR);
1343 jj_consume_token(REPLACE);
1344 break;
1345 default:
1346 jj_la1[20] = jj_gen;
1347 ;
1348 }
1349 switch (jj_nt.kind) {
1350 case EDITIONABLE:
1351 case NONEDITIONABLE:
1352 switch (jj_nt.kind) {
1353 case EDITIONABLE:
1354 jj_consume_token(EDITIONABLE);
1355 break;
1356 case NONEDITIONABLE:
1357 jj_consume_token(NONEDITIONABLE);
1358 break;
1359 default:
1360 jj_la1[21] = jj_gen;
1361 jj_consume_token(-1);
1362 throw new ParseException();
1363 }
1364 break;
1365 default:
1366 jj_la1[22] = jj_gen;
1367 ;
1368 }
1369 break;
1370 default:
1371 jj_la1[23] = jj_gen;
1372 ;
1373 }
1374 switch (jj_nt.kind) {
1375 case PACKAGE:
1376 jj_consume_token(PACKAGE);
1377 break;
1378 case TYPE:
1379 jj_consume_token(TYPE);
1380 break;
1381 default:
1382 jj_la1[24] = jj_gen;
1383 jj_consume_token(-1);
1384 throw new ParseException();
1385 }
1386 jj_consume_token(BODY);
1387 simpleNode = ObjectNameDeclaration();
1388 switch (jj_nt.kind) {
1389 case WRAPPED:
1390 WrappedObject();
1391 break;
1392 case AS:
1393 case IS:
1394 switch (jj_nt.kind) {
1395 case IS:
1396 jj_consume_token(IS);
1397 break;
1398 case AS:
1399 jj_consume_token(AS);
1400 break;
1401 default:
1402 jj_la1[25] = jj_gen;
1403 jj_consume_token(-1);
1404 throw new ParseException();
1405 }
1406 DeclarativeSection();
1407 switch (jj_nt.kind) {
1408 case BEGIN:
1409 jj_consume_token(BEGIN);
1410 label_6:
1411 while (true) {
1412 switch (jj_nt.kind) {
1413 case 5:
1414 case 16:
1415 case 17:
1416 case 21:
1417 case REPLACE:
1418 case DEFINER:
1419 case CURRENT_USER:
1420 case LANGUAGE:
1421 case INLINE:
1422 case ADD:
1423 case AGGREGATE:
1424 case ARRAY:
1425 case AT:
1426 case ATTRIBUTE:
1427 case AUTHID:
1428 case BEGIN:
1429 case BODY:
1430 case BULK:
1431 case BYTE:
1432 case CASCADE:
1433 case CASE:
1434 case CLOSE:
1435 case COALESCE:
1436 case COLLECT:
1437 case COLUMN:
1438 case COMMENT:
1439 case COMMIT:
1440 case CONSTRUCTOR:
1441 case CONTINUE:
1442 case CONVERT:
1443 case CURRENT:
1444 case CURSOR:
1445 case DATA:
1446 case DATE:
1447 case DAY:
1448 case DECLARE:
1449 case DELETE:
1450 case DISABLE:
1451 case EDITIONABLE:
1452 case ELEMENT:
1453 case ENABLE:
1454 case ESCAPE:
1455 case EXCEPT:
1456 case EXCEPTIONS:
1457 case EXECUTE:
1458 case EXIT:
1459 case EXTERNAL:
1460 case EXTENDS:
1461 case EXTRACT:
1462 case FALSE:
1463 case FETCH:
1464 case FINAL:
1465 case FOR:
1466 case FORALL:
1467 case FORCE:
1468 case FUNCTION:
1469 case GLOBAL:
1470 case GOTO:
1471 case HASH:
1472 case HEAP:
1473 case HOUR:
1474 case IF:
1475 case IMMEDIATE:
1476 case INDICES:
1477 case INDEXTYPE:
1478 case INDICATOR:
1479 case INSERT:
1480 case INSTANTIABLE:
1481 case INTERVAL:
1482 case INVALIDATE:
1483 case ISOLATION:
1484 case JAVA:
1485 case LEVEL:
1486 case LIMIT:
1487 case LOCK:
1488 case LOOP:
1489 case MAP:
1490 case MAX:
1491 case MEMBER:
1492 case MERGE:
1493 case MIN:
1494 case MINUTE:
1495 case MLSLABEL:
1496 case MODIFY:
1497 case MOD:
1498 case MONTH:
1499 case NATURAL:
1500 case NEW:
1501 case NEW_DOT:
1502 case NO:
1503 case NONEDITIONABLE:
1504 case NOT:
1505 case NULL:
1506 case NULLIF:
1507 case OBJECT:
1508 case OID:
1509 case OPAQUE:
1510 case OPEN:
1511 case OPERATOR:
1512 case ORGANIZATION:
1513 case OTHERS:
1514 case OVERRIDING:
1515 case PACKAGE:
1516 case PARTITION:
1517 case PIPE:
1518 case PRAGMA:
1519 case PRESERVE:
1520 case PRIVATE:
1521 case PROCEDURE:
1522 case RAISE:
1523 case RANGE:
1524 case RAW:
1525 case REAL:
1526 case RECORD:
1527 case REF:
1528 case RELEASE:
1529 case RELIES_ON:
1530 case RENAME:
1531 case RESULT:
1532 case RETURN:
1533 case RETURNING:
1534 case REVERSE:
1535 case ROLLBACK:
1536 case ROW:
1537 case ROWS:
1538 case ROWID:
1539 case ROWNUM:
1540 case SAVE:
1541 case SAVEPOINT:
1542 case SECOND:
1543 case SELECT:
1544 case SELF:
1545 case SET:
1546 case SPACE:
1547 case SQL:
1548 case SQLCODE:
1549 case SQLERRM:
1550 case STATIC:
1551 case SUBTYPE:
1552 case SUBSTITUTABLE:
1553 case SUCCESSFUL:
1554 case SYSDATE:
1555 case SYS_REFCURSOR:
1556 case TEMPORARY:
1557 case TIME:
1558 case TIMESTAMP:
1559 case TIMEZONE_REGION:
1560 case TIMEZONE_ABBR:
1561 case TIMEZONE_MINUTE:
1562 case TIMEZONE_HOUR:
1563 case TRANSACTION:
1564 case TRUE:
1565 case TYPE:
1566 case UNDER:
1567 case USING:
1568 case WHILE:
1569 case YES:
1570 case SHOW:
1571 case A:
1572 case UPDATE:
1573 case DOUBLE:
1574 case DEC:
1575 case PRECISION:
1576 case INT:
1577 case NUMERIC:
1578 case NCHAR:
1579 case NVARCHAR2:
1580 case STRING:
1581 case UROWID:
1582 case VARRAY:
1583 case VARYING:
1584 case BFILE:
1585 case BLOB:
1586 case CLOB:
1587 case NCLOB:
1588 case YEAR:
1589 case LOCAL:
1590 case WITH:
1591 case ZONE:
1592 case CHARACTER:
1593 case AFTER:
1594 case BEFORE:
1595 case OLD:
1596 case PARENT:
1597 case CC_IF:
1598 case CC_ERROR:
1599 case ANALYZE:
1600 case ASSOCIATE:
1601 case AUDIT:
1602 case COMPOUND:
1603 case DATABASE:
1604 case CALL:
1605 case DDL:
1606 case DISASSOCIATE:
1607 case EACH:
1608 case FOLLOWS:
1609 case LOGOFF:
1610 case LOGON:
1611 case NESTED:
1612 case NOAUDIT:
1613 case SCHEMA:
1614 case SERVERERROR:
1615 case SHUTDOWN:
1616 case STARTUP:
1617 case STATEMENT:
1618 case STATISTICS:
1619 case SUSPEND:
1620 case TRUNCATE:
1621 case WRAPPED:
1622 case LIBRARY:
1623 case NAME:
1624 case STRUCT:
1625 case CONTEXT:
1626 case PARAMETERS:
1627 case LENGTH:
1628 case TDO:
1629 case MAXLEN:
1630 case CHARSETID:
1631 case CHARSETFORM:
1632 case ACCEPT:
1633 case ACCESSIBLE:
1634 case COPY:
1635 case DEFINE:
1636 case DISCONNECT:
1637 case HOST:
1638 case PRINT:
1639 case QUIT:
1640 case REMARK:
1641 case UNDEFINE:
1642 case VARIABLE:
1643 case WHENEVER:
1644 case ATTACH:
1645 case CAST:
1646 case TREAT:
1647 case TRIM:
1648 case LEFT:
1649 case RIGHT:
1650 case BOTH:
1651 case EMPTY:
1652 case MULTISET:
1653 case SUBMULTISET:
1654 case LEADING:
1655 case TRAILING:
1656 case CHAR_CS:
1657 case NCHAR_CS:
1658 case DBTIMEZONE:
1659 case SESSIONTIMEZONE:
1660 case AUTHENTICATED:
1661 case LINK:
1662 case SHARED:
1663 case DIRECTORY:
1664 case USER:
1665 case IDENTIFIER:
1666 case UNSIGNED_NUMERIC_LITERAL:
1667 case CHARACTER_LITERAL:
1668 case STRING_LITERAL:
1669 case QUOTED_LITERAL:
1670 ;
1671 break;
1672 default:
1673 jj_la1[26] = jj_gen;
1674 break label_6;
1675 }
1676 Statement();
1677 }
1678 switch (jj_nt.kind) {
1679 case EXCEPTION:
1680 ExceptionHandler();
1681 break;
1682 default:
1683 jj_la1[27] = jj_gen;
1684 ;
1685 }
1686 break;
1687 default:
1688 jj_la1[28] = jj_gen;
1689 ;
1690 }
1691 jj_consume_token(END);
1692 switch (jj_nt.kind) {
1693 case REPLACE:
1694 case DEFINER:
1695 case CURRENT_USER:
1696 case SERIALLY_REUSABLE:
1697 case RESTRICT_REFERENCES:
1698 case EXCEPTION_INIT:
1699 case AUTONOMOUS_TRANSACTION:
1700 case LANGUAGE:
1701 case INLINE:
1702 case ADD:
1703 case AGGREGATE:
1704 case ALL:
1705 case ALTER:
1706 case AND:
1707 case ANY:
1708 case ARRAY:
1709 case AS:
1710 case ASC:
1711 case AT:
1712 case ATTRIBUTE:
1713 case AUTHID:
1714 case AVG:
1715 case BETWEEN:
1716 case BINARY_INTEGER:
1717 case BODY:
1718 case BOOLEAN:
1719 case BULK:
1720 case BY:
1721 case BYTE:
1722 case CASCADE:
1723 case CASE:
1724 case CHAR:
1725 case CHAR_BASE:
1726 case CHECK:
1727 case CLOSE:
1728 case CLUSTER:
1729 case COALESCE:
1730 case COLLECT:
1731 case COLUMN:
1732 case COMMENT:
1733 case COMMIT:
1734 case COMPRESS:
1735 case CONNECT:
1736 case CONSTANT:
1737 case CONSTRUCTOR:
1738 case CONTINUE:
1739 case CONVERT:
1740 case CREATE:
1741 case CURRENT:
1742 case CURRVAL:
1743 case CURSOR:
1744 case DATA:
1745 case DATE:
1746 case DAY:
1747 case DECLARE:
1748 case DECIMAL:
1749 case _DEFAULT:
1750 case DELETE:
1751 case DESC:
1752 case DISABLE:
1753 case DISTINCT:
1754 case DO:
1755 case DROP:
1756 case EDITIONABLE:
1757 case ELEMENT:
1758 case ELSE:
1759 case ELSIF:
1760 case ENABLE:
1761 case ESCAPE:
1762 case EXCEPT:
1763 case EXCEPTION:
1764 case EXCEPTIONS:
1765 case EXCLUSIVE:
1766 case EXECUTE:
1767 case EXISTS:
1768 case EXIT:
1769 case EXTERNAL:
1770 case EXTENDS:
1771 case EXTRACT:
1772 case FALSE:
1773 case FETCH:
1774 case FINAL:
1775 case FLOAT:
1776 case FOR:
1777 case FORALL:
1778 case FORCE:
1779 case FROM:
1780 case FUNCTION:
1781 case GLOBAL:
1782 case GOTO:
1783 case GROUP:
1784 case HASH:
1785 case HAVING:
1786 case HEAP:
1787 case HOUR:
1788 case IF:
1789 case IMMEDIATE:
1790 case IN:
1791 case INDEX:
1792 case INDICES:
1793 case INDEXTYPE:
1794 case INDICATOR:
1795 case INSERT:
1796 case INSTANTIABLE:
1797 case INTEGER:
1798 case INTERFACE:
1799 case INTERSECT:
1800 case INTERVAL:
1801 case INTO:
1802 case INVALIDATE:
1803 case IS:
1804 case ISOLATION:
1805 case JAVA:
1806 case LEVEL:
1807 case LIKE:
1808 case LIMIT:
1809 case LIMITED:
1810 case LOCK:
1811 case LONG:
1812 case LOOP:
1813 case MAP:
1814 case MAX:
1815 case MEMBER:
1816 case MERGE:
1817 case MIN:
1818 case MINUS:
1819 case MINUTE:
1820 case MLSLABEL:
1821 case MODIFY:
1822 case MOD:
1823 case MODE:
1824 case MONTH:
1825 case NATURAL:
1826 case NATURALN:
1827 case NEW:
1828 case NEXTVAL:
1829 case NO:
1830 case NOCOPY:
1831 case NONEDITIONABLE:
1832 case NOT:
1833 case NOWAIT:
1834 case NULL:
1835 case NULLIF:
1836 case NUMBER:
1837 case BFILE_BASE:
1838 case BLOB_BASE:
1839 case CLOB_BASE:
1840 case DATE_BASE:
1841 case NUMBER_BASE:
1842 case OBJECT:
1843 case OCIROWID:
1844 case OF:
1845 case OID:
1846 case ON:
1847 case OPAQUE:
1848 case OPEN:
1849 case OPERATOR:
1850 case OPTION:
1851 case OR:
1852 case ORDER:
1853 case ORGANIZATION:
1854 case OTHERS:
1855 case OUT:
1856 case OVERRIDING:
1857 case PACKAGE:
1858 case PARTITION:
1859 case PCTFREE:
1860 case PLS_INTEGER:
1861 case POSITIVE:
1862 case POSITIVEN:
1863 case PRESERVE:
1864 case PRIOR:
1865 case PROMPT:
1866 case PRIVATE:
1867 case PROCEDURE:
1868 case PUBLIC:
1869 case RAISE:
1870 case RANGE:
1871 case RAW:
1872 case REAL:
1873 case RECORD:
1874 case REF:
1875 case RELEASE:
1876 case RELIES_ON:
1877 case RENAME:
1878 case RESULT:
1879 case RETURN:
1880 case RETURNING:
1881 case REVERSE:
1882 case ROLLBACK:
1883 case ROW:
1884 case ROWS:
1885 case ROWID:
1886 case ROWNUM:
1887 case ROWTYPE:
1888 case SAVE:
1889 case SAVEPOINT:
1890 case SECOND:
1891 case SELECT:
1892 case SELF:
1893 case SEPARATE:
1894 case SET:
1895 case SHARE:
1896 case SMALLINT:
1897 case SPACE:
1898 case SQL:
1899 case SQLCODE:
1900 case SQLERRM:
1901 case START:
1902 case STATIC:
1903 case STDDEV:
1904 case SUBTYPE:
1905 case SUBSTITUTABLE:
1906 case SUCCESSFUL:
1907 case SUM:
1908 case SYNONYM:
1909 case SYSDATE:
1910 case SYS_REFCURSOR:
1911 case TABLE:
1912 case TEMPORARY:
1913 case THEN:
1914 case TIME:
1915 case TIMESTAMP:
1916 case TIMEZONE_REGION:
1917 case TIMEZONE_ABBR:
1918 case TIMEZONE_MINUTE:
1919 case TIMEZONE_HOUR:
1920 case TO:
1921 case TRANSACTION:
1922 case TRIGGER:
1923 case TRUE:
1924 case TYPE:
1925 case UI:
1926 case UNDER:
1927 case USING:
1928 case WHILE:
1929 case YES:
1930 case SHOW:
1931 case A:
1932 case UPDATE:
1933 case VARCHAR:
1934 case VARCHAR2:
1935 case DOUBLE:
1936 case DEC:
1937 case PRECISION:
1938 case INT:
1939 case NUMERIC:
1940 case SIGNTYPE:
1941 case NCHAR:
1942 case NVARCHAR2:
1943 case STRING:
1944 case UROWID:
1945 case VARRAY:
1946 case VARYING:
1947 case BFILE:
1948 case BLOB:
1949 case CLOB:
1950 case NCLOB:
1951 case YEAR:
1952 case LOCAL:
1953 case WITH:
1954 case ZONE:
1955 case CHARACTER:
1956 case AFTER:
1957 case BEFORE:
1958 case OLD:
1959 case PARENT:
1960 case ANALYZE:
1961 case ASSOCIATE:
1962 case AUDIT:
1963 case COMPOUND:
1964 case DATABASE:
1965 case CALL:
1966 case DDL:
1967 case DISASSOCIATE:
1968 case EACH:
1969 case FOLLOWS:
1970 case LOGOFF:
1971 case LOGON:
1972 case NESTED:
1973 case NOAUDIT:
1974 case SCHEMA:
1975 case SERVERERROR:
1976 case SHUTDOWN:
1977 case STARTUP:
1978 case STATEMENT:
1979 case STATISTICS:
1980 case SUSPEND:
1981 case TRUNCATE:
1982 case WRAPPED:
1983 case LIBRARY:
1984 case NAME:
1985 case STRUCT:
1986 case CONTEXT:
1987 case PARAMETERS:
1988 case LENGTH:
1989 case TDO:
1990 case MAXLEN:
1991 case CHARSETID:
1992 case CHARSETFORM:
1993 case ACCEPT:
1994 case ACCESSIBLE:
1995 case COPY:
1996 case DEFINE:
1997 case DISCONNECT:
1998 case HOST:
1999 case PRINT:
2000 case QUIT:
2001 case REMARK:
2002 case UNDEFINE:
2003 case VARIABLE:
2004 case WHENEVER:
2005 case ATTACH:
2006 case CAST:
2007 case TREAT:
2008 case TRIM:
2009 case LEFT:
2010 case RIGHT:
2011 case BOTH:
2012 case EMPTY:
2013 case MULTISET:
2014 case SUBMULTISET:
2015 case LEADING:
2016 case TRAILING:
2017 case CHAR_CS:
2018 case NCHAR_CS:
2019 case DBTIMEZONE:
2020 case SESSIONTIMEZONE:
2021 case AUTHENTICATED:
2022 case LINK:
2023 case SHARED:
2024 case DIRECTORY:
2025 case USER:
2026 case IDENTIFIER:
2027 case QUOTED_LITERAL:
2028 case SQLDATA_CLASS:
2029 case CUSTOMDATUM_CLASS:
2030 case ORADATA_CLASS:
2031 case JAVA_INTERFACE_CLASS:
2032 ID();
2033 break;
2034 default:
2035 jj_la1[29] = jj_gen;
2036 ;
2037 }
2038 jj_consume_token(4);
2039 break;
2040 default:
2041 jj_la1[30] = jj_gen;
2042 jj_consume_token(-1);
2043 throw new ParseException();
2044 }
2045 jjtree.closeNodeScope(jjtn000, true);
2046 jjtc000 = false;
2047 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
2048 } catch (Throwable jjte000) {
2049 if (jjtc000) {
2050 jjtree.clearNodeScope(jjtn000);
2051 jjtc000 = false;
2052 } else {
2053 jjtree.popNode();
2054 }
2055 if (jjte000 instanceof RuntimeException) {
2056 {if (true) throw (RuntimeException)jjte000;}
2057 }
2058 if (jjte000 instanceof ParseException) {
2059 {if (true) throw (ParseException)jjte000;}
2060 }
2061 {if (true) throw (Error)jjte000;}
2062 } finally {
2063 if (jjtc000) {
2064 jjtree.closeNodeScope(jjtn000, true);
2065 }
2066 }
2067 throw new Error("Missing return statement in function");
2068 }
2069
2070 final public ASTDeclarativeUnit DeclarativeUnit() throws ParseException {
2071
2072 ASTDeclarativeUnit jjtn000 = new ASTDeclarativeUnit(this, JJTDECLARATIVEUNIT);
2073 boolean jjtc000 = true;
2074 jjtree.openNodeScope(jjtn000);
2075 try {
2076 switch (jj_nt.kind) {
2077 case PRAGMA:
2078 Pragma();
2079 break;
2080 default:
2081 jj_la1[31] = jj_gen;
2082 if (jj_2_16(2)) {
2083 ExceptionDeclaration();
2084 } else if (jj_2_17(2147483647)) {
2085 SubTypeDefinition();
2086 } else if (jj_2_18(2147483647)) {
2087 ProgramUnit();
2088 } else if (jj_2_19(4)) {
2089 VariableOrConstantDeclaration();
2090 } else if (jj_2_20(2)) {
2091 CursorSpecification();
2092 } else {
2093 switch (jj_nt.kind) {
2094 case CURSOR:
2095 CursorBody();
2096 break;
2097 case IDENTIFIER:
2098 CollectionDeclaration();
2099 break;
2100 case CONSTRUCTOR:
2101 case CREATE:
2102 case FINAL:
2103 case FUNCTION:
2104 case INSTANTIABLE:
2105 case MAP:
2106 case MEMBER:
2107 case NOT:
2108 case ORDER:
2109 case OVERRIDING:
2110 case PROCEDURE:
2111 case STATIC:
2112 MethodDeclaration();
2113 break;
2114 case CC_IF:
2115 CompilationDeclarationFragment();
2116 break;
2117 default:
2118 jj_la1[32] = jj_gen;
2119 jj_consume_token(-1);
2120 throw new ParseException();
2121 }
2122 }
2123 }
2124 jjtree.closeNodeScope(jjtn000, true);
2125 jjtc000 = false;
2126 {if (true) return jjtn000 ;}
2127 } catch (Throwable jjte000) {
2128 if (jjtc000) {
2129 jjtree.clearNodeScope(jjtn000);
2130 jjtc000 = false;
2131 } else {
2132 jjtree.popNode();
2133 }
2134 if (jjte000 instanceof RuntimeException) {
2135 {if (true) throw (RuntimeException)jjte000;}
2136 }
2137 if (jjte000 instanceof ParseException) {
2138 {if (true) throw (ParseException)jjte000;}
2139 }
2140 {if (true) throw (Error)jjte000;}
2141 } finally {
2142 if (jjtc000) {
2143 jjtree.closeNodeScope(jjtn000, true);
2144 }
2145 }
2146 throw new Error("Missing return statement in function");
2147 }
2148
2149 final public ASTDeclarativeSection DeclarativeSection() throws ParseException {
2150
2151 ASTDeclarativeSection jjtn000 = new ASTDeclarativeSection(this, JJTDECLARATIVESECTION);
2152 boolean jjtc000 = true;
2153 jjtree.openNodeScope(jjtn000);
2154 try {
2155 label_7:
2156 while (true) {
2157 switch (jj_nt.kind) {
2158 case REPLACE:
2159 case DEFINER:
2160 case CURRENT_USER:
2161 case SERIALLY_REUSABLE:
2162 case RESTRICT_REFERENCES:
2163 case EXCEPTION_INIT:
2164 case AUTONOMOUS_TRANSACTION:
2165 case LANGUAGE:
2166 case INLINE:
2167 case ADD:
2168 case AGGREGATE:
2169 case ALL:
2170 case ALTER:
2171 case AND:
2172 case ANY:
2173 case ARRAY:
2174 case AS:
2175 case ASC:
2176 case AT:
2177 case ATTRIBUTE:
2178 case AUTHID:
2179 case AVG:
2180 case BETWEEN:
2181 case BINARY_INTEGER:
2182 case BODY:
2183 case BOOLEAN:
2184 case BULK:
2185 case BY:
2186 case BYTE:
2187 case CASCADE:
2188 case CASE:
2189 case CHAR:
2190 case CHAR_BASE:
2191 case CHECK:
2192 case CLOSE:
2193 case CLUSTER:
2194 case COALESCE:
2195 case COLLECT:
2196 case COLUMN:
2197 case COMMENT:
2198 case COMMIT:
2199 case COMPRESS:
2200 case CONNECT:
2201 case CONSTANT:
2202 case CONSTRUCTOR:
2203 case CONTINUE:
2204 case CONVERT:
2205 case CREATE:
2206 case CURRENT:
2207 case CURRVAL:
2208 case CURSOR:
2209 case DATA:
2210 case DATE:
2211 case DAY:
2212 case DECLARE:
2213 case DECIMAL:
2214 case _DEFAULT:
2215 case DELETE:
2216 case DESC:
2217 case DISABLE:
2218 case DISTINCT:
2219 case DO:
2220 case DROP:
2221 case EDITIONABLE:
2222 case ELEMENT:
2223 case ELSE:
2224 case ELSIF:
2225 case ENABLE:
2226 case ESCAPE:
2227 case EXCEPT:
2228 case EXCEPTION:
2229 case EXCEPTIONS:
2230 case EXCLUSIVE:
2231 case EXECUTE:
2232 case EXISTS:
2233 case EXIT:
2234 case EXTERNAL:
2235 case EXTENDS:
2236 case EXTRACT:
2237 case FALSE:
2238 case FETCH:
2239 case FINAL:
2240 case FLOAT:
2241 case FOR:
2242 case FORALL:
2243 case FORCE:
2244 case FROM:
2245 case FUNCTION:
2246 case GLOBAL:
2247 case GOTO:
2248 case GROUP:
2249 case HASH:
2250 case HAVING:
2251 case HEAP:
2252 case HOUR:
2253 case IF:
2254 case IMMEDIATE:
2255 case IN:
2256 case INDEX:
2257 case INDICES:
2258 case INDEXTYPE:
2259 case INDICATOR:
2260 case INSERT:
2261 case INSTANTIABLE:
2262 case INTEGER:
2263 case INTERFACE:
2264 case INTERSECT:
2265 case INTERVAL:
2266 case INTO:
2267 case INVALIDATE:
2268 case IS:
2269 case ISOLATION:
2270 case JAVA:
2271 case LEVEL:
2272 case LIKE:
2273 case LIMIT:
2274 case LIMITED:
2275 case LOCK:
2276 case LONG:
2277 case LOOP:
2278 case MAP:
2279 case MAX:
2280 case MEMBER:
2281 case MERGE:
2282 case MIN:
2283 case MINUS:
2284 case MINUTE:
2285 case MLSLABEL:
2286 case MODIFY:
2287 case MOD:
2288 case MODE:
2289 case MONTH:
2290 case NATURAL:
2291 case NATURALN:
2292 case NEW:
2293 case NEXTVAL:
2294 case NO:
2295 case NOCOPY:
2296 case NONEDITIONABLE:
2297 case NOT:
2298 case NOWAIT:
2299 case NULL:
2300 case NULLIF:
2301 case NUMBER:
2302 case BFILE_BASE:
2303 case BLOB_BASE:
2304 case CLOB_BASE:
2305 case DATE_BASE:
2306 case NUMBER_BASE:
2307 case OBJECT:
2308 case OCIROWID:
2309 case OF:
2310 case OID:
2311 case ON:
2312 case OPAQUE:
2313 case OPEN:
2314 case OPERATOR:
2315 case OPTION:
2316 case OR:
2317 case ORDER:
2318 case ORGANIZATION:
2319 case OTHERS:
2320 case OUT:
2321 case OVERRIDING:
2322 case PACKAGE:
2323 case PARTITION:
2324 case PCTFREE:
2325 case PLS_INTEGER:
2326 case POSITIVE:
2327 case POSITIVEN:
2328 case PRAGMA:
2329 case PRESERVE:
2330 case PRIOR:
2331 case PROMPT:
2332 case PRIVATE:
2333 case PROCEDURE:
2334 case PUBLIC:
2335 case RAISE:
2336 case RANGE:
2337 case RAW:
2338 case REAL:
2339 case RECORD:
2340 case REF:
2341 case RELEASE:
2342 case RELIES_ON:
2343 case RENAME:
2344 case RESULT:
2345 case RETURN:
2346 case RETURNING:
2347 case REVERSE:
2348 case ROLLBACK:
2349 case ROW:
2350 case ROWS:
2351 case ROWID:
2352 case ROWNUM:
2353 case ROWTYPE:
2354 case SAVE:
2355 case SAVEPOINT:
2356 case SECOND:
2357 case SELECT:
2358 case SELF:
2359 case SEPARATE:
2360 case SET:
2361 case SHARE:
2362 case SMALLINT:
2363 case SPACE:
2364 case SQL:
2365 case SQLCODE:
2366 case SQLERRM:
2367 case START:
2368 case STATIC:
2369 case STDDEV:
2370 case SUBTYPE:
2371 case SUBSTITUTABLE:
2372 case SUCCESSFUL:
2373 case SUM:
2374 case SYNONYM:
2375 case SYSDATE:
2376 case SYS_REFCURSOR:
2377 case TABLE:
2378 case TEMPORARY:
2379 case THEN:
2380 case TIME:
2381 case TIMESTAMP:
2382 case TIMEZONE_REGION:
2383 case TIMEZONE_ABBR:
2384 case TIMEZONE_MINUTE:
2385 case TIMEZONE_HOUR:
2386 case TO:
2387 case TRANSACTION:
2388 case TRIGGER:
2389 case TRUE:
2390 case TYPE:
2391 case UI:
2392 case UNDER:
2393 case USING:
2394 case WHILE:
2395 case YES:
2396 case SHOW:
2397 case A:
2398 case UPDATE:
2399 case VARCHAR:
2400 case VARCHAR2:
2401 case DOUBLE:
2402 case DEC:
2403 case PRECISION:
2404 case INT:
2405 case NUMERIC:
2406 case SIGNTYPE:
2407 case NCHAR:
2408 case NVARCHAR2:
2409 case STRING:
2410 case UROWID:
2411 case VARRAY:
2412 case VARYING:
2413 case BFILE:
2414 case BLOB:
2415 case CLOB:
2416 case NCLOB:
2417 case YEAR:
2418 case LOCAL:
2419 case WITH:
2420 case ZONE:
2421 case CHARACTER:
2422 case AFTER:
2423 case BEFORE:
2424 case OLD:
2425 case PARENT:
2426 case CC_IF:
2427 case ANALYZE:
2428 case ASSOCIATE:
2429 case AUDIT:
2430 case COMPOUND:
2431 case DATABASE:
2432 case CALL:
2433 case DDL:
2434 case DISASSOCIATE:
2435 case EACH:
2436 case FOLLOWS:
2437 case LOGOFF:
2438 case LOGON:
2439 case NESTED:
2440 case NOAUDIT:
2441 case SCHEMA:
2442 case SERVERERROR:
2443 case SHUTDOWN:
2444 case STARTUP:
2445 case STATEMENT:
2446 case STATISTICS:
2447 case SUSPEND:
2448 case TRUNCATE:
2449 case WRAPPED:
2450 case LIBRARY:
2451 case NAME:
2452 case STRUCT:
2453 case CONTEXT:
2454 case PARAMETERS:
2455 case LENGTH:
2456 case TDO:
2457 case MAXLEN:
2458 case CHARSETID:
2459 case CHARSETFORM:
2460 case ACCEPT:
2461 case ACCESSIBLE:
2462 case COPY:
2463 case DEFINE:
2464 case DISCONNECT:
2465 case HOST:
2466 case PRINT:
2467 case QUIT:
2468 case REMARK:
2469 case UNDEFINE:
2470 case VARIABLE:
2471 case WHENEVER:
2472 case ATTACH:
2473 case CAST:
2474 case TREAT:
2475 case TRIM:
2476 case LEFT:
2477 case RIGHT:
2478 case BOTH:
2479 case EMPTY:
2480 case MULTISET:
2481 case SUBMULTISET:
2482 case LEADING:
2483 case TRAILING:
2484 case CHAR_CS:
2485 case NCHAR_CS:
2486 case DBTIMEZONE:
2487 case SESSIONTIMEZONE:
2488 case AUTHENTICATED:
2489 case LINK:
2490 case SHARED:
2491 case DIRECTORY:
2492 case USER:
2493 case IDENTIFIER:
2494 case QUOTED_LITERAL:
2495 case SQLDATA_CLASS:
2496 case CUSTOMDATUM_CLASS:
2497 case ORADATA_CLASS:
2498 case JAVA_INTERFACE_CLASS:
2499 ;
2500 break;
2501 default:
2502 jj_la1[33] = jj_gen;
2503 break label_7;
2504 }
2505 DeclarativeUnit();
2506 }
2507 jjtree.closeNodeScope(jjtn000, true);
2508 jjtc000 = false;
2509 {if (true) return jjtn000 ;}
2510 } catch (Throwable jjte000) {
2511 if (jjtc000) {
2512 jjtree.clearNodeScope(jjtn000);
2513 jjtc000 = false;
2514 } else {
2515 jjtree.popNode();
2516 }
2517 if (jjte000 instanceof RuntimeException) {
2518 {if (true) throw (RuntimeException)jjte000;}
2519 }
2520 if (jjte000 instanceof ParseException) {
2521 {if (true) throw (ParseException)jjte000;}
2522 }
2523 {if (true) throw (Error)jjte000;}
2524 } finally {
2525 if (jjtc000) {
2526 jjtree.closeNodeScope(jjtn000, true);
2527 }
2528 }
2529 throw new Error("Missing return statement in function");
2530 }
2531
2532 final public ASTCompilationDeclarationFragment CompilationDeclarationFragment() throws ParseException {
2533
2534 ASTCompilationDeclarationFragment jjtn000 = new ASTCompilationDeclarationFragment(this, JJTCOMPILATIONDECLARATIONFRAGMENT);
2535 boolean jjtc000 = true;
2536 jjtree.openNodeScope(jjtn000);
2537 try {
2538 jj_consume_token(CC_IF);
2539 ConditionalOrExpression();
2540 jj_consume_token(CC_THEN);
2541 label_8:
2542 while (true) {
2543 switch (jj_nt.kind) {
2544 case REPLACE:
2545 case DEFINER:
2546 case CURRENT_USER:
2547 case SERIALLY_REUSABLE:
2548 case RESTRICT_REFERENCES:
2549 case EXCEPTION_INIT:
2550 case AUTONOMOUS_TRANSACTION:
2551 case LANGUAGE:
2552 case INLINE:
2553 case ADD:
2554 case AGGREGATE:
2555 case ALL:
2556 case ALTER:
2557 case AND:
2558 case ANY:
2559 case ARRAY:
2560 case AS:
2561 case ASC:
2562 case AT:
2563 case ATTRIBUTE:
2564 case AUTHID:
2565 case AVG:
2566 case BETWEEN:
2567 case BINARY_INTEGER:
2568 case BODY:
2569 case BOOLEAN:
2570 case BULK:
2571 case BY:
2572 case BYTE:
2573 case CASCADE:
2574 case CASE:
2575 case CHAR:
2576 case CHAR_BASE:
2577 case CHECK:
2578 case CLOSE:
2579 case CLUSTER:
2580 case COALESCE:
2581 case COLLECT:
2582 case COLUMN:
2583 case COMMENT:
2584 case COMMIT:
2585 case COMPRESS:
2586 case CONNECT:
2587 case CONSTANT:
2588 case CONSTRUCTOR:
2589 case CONTINUE:
2590 case CONVERT:
2591 case CREATE:
2592 case CURRENT:
2593 case CURRVAL:
2594 case CURSOR:
2595 case DATA:
2596 case DATE:
2597 case DAY:
2598 case DECLARE:
2599 case DECIMAL:
2600 case _DEFAULT:
2601 case DELETE:
2602 case DESC:
2603 case DISABLE:
2604 case DISTINCT:
2605 case DO:
2606 case DROP:
2607 case EDITIONABLE:
2608 case ELEMENT:
2609 case ELSE:
2610 case ELSIF:
2611 case ENABLE:
2612 case ESCAPE:
2613 case EXCEPT:
2614 case EXCEPTION:
2615 case EXCEPTIONS:
2616 case EXCLUSIVE:
2617 case EXECUTE:
2618 case EXISTS:
2619 case EXIT:
2620 case EXTERNAL:
2621 case EXTENDS:
2622 case EXTRACT:
2623 case FALSE:
2624 case FETCH:
2625 case FINAL:
2626 case FLOAT:
2627 case FOR:
2628 case FORALL:
2629 case FORCE:
2630 case FROM:
2631 case FUNCTION:
2632 case GLOBAL:
2633 case GOTO:
2634 case GROUP:
2635 case HASH:
2636 case HAVING:
2637 case HEAP:
2638 case HOUR:
2639 case IF:
2640 case IMMEDIATE:
2641 case IN:
2642 case INDEX:
2643 case INDICES:
2644 case INDEXTYPE:
2645 case INDICATOR:
2646 case INSERT:
2647 case INSTANTIABLE:
2648 case INTEGER:
2649 case INTERFACE:
2650 case INTERSECT:
2651 case INTERVAL:
2652 case INTO:
2653 case INVALIDATE:
2654 case IS:
2655 case ISOLATION:
2656 case JAVA:
2657 case LEVEL:
2658 case LIKE:
2659 case LIMIT:
2660 case LIMITED:
2661 case LOCK:
2662 case LONG:
2663 case LOOP:
2664 case MAP:
2665 case MAX:
2666 case MEMBER:
2667 case MERGE:
2668 case MIN:
2669 case MINUS:
2670 case MINUTE:
2671 case MLSLABEL:
2672 case MODIFY:
2673 case MOD:
2674 case MODE:
2675 case MONTH:
2676 case NATURAL:
2677 case NATURALN:
2678 case NEW:
2679 case NEXTVAL:
2680 case NO:
2681 case NOCOPY:
2682 case NONEDITIONABLE:
2683 case NOT:
2684 case NOWAIT:
2685 case NULL:
2686 case NULLIF:
2687 case NUMBER:
2688 case BFILE_BASE:
2689 case BLOB_BASE:
2690 case CLOB_BASE:
2691 case DATE_BASE:
2692 case NUMBER_BASE:
2693 case OBJECT:
2694 case OCIROWID:
2695 case OF:
2696 case OID:
2697 case ON:
2698 case OPAQUE:
2699 case OPEN:
2700 case OPERATOR:
2701 case OPTION:
2702 case OR:
2703 case ORDER:
2704 case ORGANIZATION:
2705 case OTHERS:
2706 case OUT:
2707 case OVERRIDING:
2708 case PACKAGE:
2709 case PARTITION:
2710 case PCTFREE:
2711 case PLS_INTEGER:
2712 case POSITIVE:
2713 case POSITIVEN:
2714 case PRAGMA:
2715 case PRESERVE:
2716 case PRIOR:
2717 case PROMPT:
2718 case PRIVATE:
2719 case PROCEDURE:
2720 case PUBLIC:
2721 case RAISE:
2722 case RANGE:
2723 case RAW:
2724 case REAL:
2725 case RECORD:
2726 case REF:
2727 case RELEASE:
2728 case RELIES_ON:
2729 case RENAME:
2730 case RESULT:
2731 case RETURN:
2732 case RETURNING:
2733 case REVERSE:
2734 case ROLLBACK:
2735 case ROW:
2736 case ROWS:
2737 case ROWID:
2738 case ROWNUM:
2739 case ROWTYPE:
2740 case SAVE:
2741 case SAVEPOINT:
2742 case SECOND:
2743 case SELECT:
2744 case SELF:
2745 case SEPARATE:
2746 case SET:
2747 case SHARE:
2748 case SMALLINT:
2749 case SPACE:
2750 case SQL:
2751 case SQLCODE:
2752 case SQLERRM:
2753 case START:
2754 case STATIC:
2755 case STDDEV:
2756 case SUBTYPE:
2757 case SUBSTITUTABLE:
2758 case SUCCESSFUL:
2759 case SUM:
2760 case SYNONYM:
2761 case SYSDATE:
2762 case SYS_REFCURSOR:
2763 case TABLE:
2764 case TEMPORARY:
2765 case THEN:
2766 case TIME:
2767 case TIMESTAMP:
2768 case TIMEZONE_REGION:
2769 case TIMEZONE_ABBR:
2770 case TIMEZONE_MINUTE:
2771 case TIMEZONE_HOUR:
2772 case TO:
2773 case TRANSACTION:
2774 case TRIGGER:
2775 case TRUE:
2776 case TYPE:
2777 case UI:
2778 case UNDER:
2779 case USING:
2780 case WHILE:
2781 case YES:
2782 case SHOW:
2783 case A:
2784 case UPDATE:
2785 case VARCHAR:
2786 case VARCHAR2:
2787 case DOUBLE:
2788 case DEC:
2789 case PRECISION:
2790 case INT:
2791 case NUMERIC:
2792 case SIGNTYPE:
2793 case NCHAR:
2794 case NVARCHAR2:
2795 case STRING:
2796 case UROWID:
2797 case VARRAY:
2798 case VARYING:
2799 case BFILE:
2800 case BLOB:
2801 case CLOB:
2802 case NCLOB:
2803 case YEAR:
2804 case LOCAL:
2805 case WITH:
2806 case ZONE:
2807 case CHARACTER:
2808 case AFTER:
2809 case BEFORE:
2810 case OLD:
2811 case PARENT:
2812 case CC_IF:
2813 case CC_ERROR:
2814 case ANALYZE:
2815 case ASSOCIATE:
2816 case AUDIT:
2817 case COMPOUND:
2818 case DATABASE:
2819 case CALL:
2820 case DDL:
2821 case DISASSOCIATE:
2822 case EACH:
2823 case FOLLOWS:
2824 case LOGOFF:
2825 case LOGON:
2826 case NESTED:
2827 case NOAUDIT:
2828 case SCHEMA:
2829 case SERVERERROR:
2830 case SHUTDOWN:
2831 case STARTUP:
2832 case STATEMENT:
2833 case STATISTICS:
2834 case SUSPEND:
2835 case TRUNCATE:
2836 case WRAPPED:
2837 case LIBRARY:
2838 case NAME:
2839 case STRUCT:
2840 case CONTEXT:
2841 case PARAMETERS:
2842 case LENGTH:
2843 case TDO:
2844 case MAXLEN:
2845 case CHARSETID:
2846 case CHARSETFORM:
2847 case ACCEPT:
2848 case ACCESSIBLE:
2849 case COPY:
2850 case DEFINE:
2851 case DISCONNECT:
2852 case HOST:
2853 case PRINT:
2854 case QUIT:
2855 case REMARK:
2856 case UNDEFINE:
2857 case VARIABLE:
2858 case WHENEVER:
2859 case ATTACH:
2860 case CAST:
2861 case TREAT:
2862 case TRIM:
2863 case LEFT:
2864 case RIGHT:
2865 case BOTH:
2866 case EMPTY:
2867 case MULTISET:
2868 case SUBMULTISET:
2869 case LEADING:
2870 case TRAILING:
2871 case CHAR_CS:
2872 case NCHAR_CS:
2873 case DBTIMEZONE:
2874 case SESSIONTIMEZONE:
2875 case AUTHENTICATED:
2876 case LINK:
2877 case SHARED:
2878 case DIRECTORY:
2879 case USER:
2880 case IDENTIFIER:
2881 case QUOTED_LITERAL:
2882 case SQLDATA_CLASS:
2883 case CUSTOMDATUM_CLASS:
2884 case ORADATA_CLASS:
2885 case JAVA_INTERFACE_CLASS:
2886 ;
2887 break;
2888 default:
2889 jj_la1[34] = jj_gen;
2890 break label_8;
2891 }
2892 switch (jj_nt.kind) {
2893 case REPLACE:
2894 case DEFINER:
2895 case CURRENT_USER:
2896 case SERIALLY_REUSABLE:
2897 case RESTRICT_REFERENCES:
2898 case EXCEPTION_INIT:
2899 case AUTONOMOUS_TRANSACTION:
2900 case LANGUAGE:
2901 case INLINE:
2902 case ADD:
2903 case AGGREGATE:
2904 case ALL:
2905 case ALTER:
2906 case AND:
2907 case ANY:
2908 case ARRAY:
2909 case AS:
2910 case ASC:
2911 case AT:
2912 case ATTRIBUTE:
2913 case AUTHID:
2914 case AVG:
2915 case BETWEEN:
2916 case BINARY_INTEGER:
2917 case BODY:
2918 case BOOLEAN:
2919 case BULK:
2920 case BY:
2921 case BYTE:
2922 case CASCADE:
2923 case CASE:
2924 case CHAR:
2925 case CHAR_BASE:
2926 case CHECK:
2927 case CLOSE:
2928 case CLUSTER:
2929 case COALESCE:
2930 case COLLECT:
2931 case COLUMN:
2932 case COMMENT:
2933 case COMMIT:
2934 case COMPRESS:
2935 case CONNECT:
2936 case CONSTANT:
2937 case CONSTRUCTOR:
2938 case CONTINUE:
2939 case CONVERT:
2940 case CREATE:
2941 case CURRENT:
2942 case CURRVAL:
2943 case CURSOR:
2944 case DATA:
2945 case DATE:
2946 case DAY:
2947 case DECLARE:
2948 case DECIMAL:
2949 case _DEFAULT:
2950 case DELETE:
2951 case DESC:
2952 case DISABLE:
2953 case DISTINCT:
2954 case DO:
2955 case DROP:
2956 case EDITIONABLE:
2957 case ELEMENT:
2958 case ELSE:
2959 case ELSIF:
2960 case ENABLE:
2961 case ESCAPE:
2962 case EXCEPT:
2963 case EXCEPTION:
2964 case EXCEPTIONS:
2965 case EXCLUSIVE:
2966 case EXECUTE:
2967 case EXISTS:
2968 case EXIT:
2969 case EXTERNAL:
2970 case EXTENDS:
2971 case EXTRACT:
2972 case FALSE:
2973 case FETCH:
2974 case FINAL:
2975 case FLOAT:
2976 case FOR:
2977 case FORALL:
2978 case FORCE:
2979 case FROM:
2980 case FUNCTION:
2981 case GLOBAL:
2982 case GOTO:
2983 case GROUP:
2984 case HASH:
2985 case HAVING:
2986 case HEAP:
2987 case HOUR:
2988 case IF:
2989 case IMMEDIATE:
2990 case IN:
2991 case INDEX:
2992 case INDICES:
2993 case INDEXTYPE:
2994 case INDICATOR:
2995 case INSERT:
2996 case INSTANTIABLE:
2997 case INTEGER:
2998 case INTERFACE:
2999 case INTERSECT:
3000 case INTERVAL:
3001 case INTO:
3002 case INVALIDATE:
3003 case IS:
3004 case ISOLATION:
3005 case JAVA:
3006 case LEVEL:
3007 case LIKE:
3008 case LIMIT:
3009 case LIMITED:
3010 case LOCK:
3011 case LONG:
3012 case LOOP:
3013 case MAP:
3014 case MAX:
3015 case MEMBER:
3016 case MERGE:
3017 case MIN:
3018 case MINUS:
3019 case MINUTE:
3020 case MLSLABEL:
3021 case MODIFY:
3022 case MOD:
3023 case MODE:
3024 case MONTH:
3025 case NATURAL:
3026 case NATURALN:
3027 case NEW:
3028 case NEXTVAL:
3029 case NO:
3030 case NOCOPY:
3031 case NONEDITIONABLE:
3032 case NOT:
3033 case NOWAIT:
3034 case NULL:
3035 case NULLIF:
3036 case NUMBER:
3037 case BFILE_BASE:
3038 case BLOB_BASE:
3039 case CLOB_BASE:
3040 case DATE_BASE:
3041 case NUMBER_BASE:
3042 case OBJECT:
3043 case OCIROWID:
3044 case OF:
3045 case OID:
3046 case ON:
3047 case OPAQUE:
3048 case OPEN:
3049 case OPERATOR:
3050 case OPTION:
3051 case OR:
3052 case ORDER:
3053 case ORGANIZATION:
3054 case OTHERS:
3055 case OUT:
3056 case OVERRIDING:
3057 case PACKAGE:
3058 case PARTITION:
3059 case PCTFREE:
3060 case PLS_INTEGER:
3061 case POSITIVE:
3062 case POSITIVEN:
3063 case PRAGMA:
3064 case PRESERVE:
3065 case PRIOR:
3066 case PROMPT:
3067 case PRIVATE:
3068 case PROCEDURE:
3069 case PUBLIC:
3070 case RAISE:
3071 case RANGE:
3072 case RAW:
3073 case REAL:
3074 case RECORD:
3075 case REF:
3076 case RELEASE:
3077 case RELIES_ON:
3078 case RENAME:
3079 case RESULT:
3080 case RETURN:
3081 case RETURNING:
3082 case REVERSE:
3083 case ROLLBACK:
3084 case ROW:
3085 case ROWS:
3086 case ROWID:
3087 case ROWNUM:
3088 case ROWTYPE:
3089 case SAVE:
3090 case SAVEPOINT:
3091 case SECOND:
3092 case SELECT:
3093 case SELF:
3094 case SEPARATE:
3095 case SET:
3096 case SHARE:
3097 case SMALLINT:
3098 case SPACE:
3099 case SQL:
3100 case SQLCODE:
3101 case SQLERRM:
3102 case START:
3103 case STATIC:
3104 case STDDEV:
3105 case SUBTYPE:
3106 case SUBSTITUTABLE:
3107 case SUCCESSFUL:
3108 case SUM:
3109 case SYNONYM:
3110 case SYSDATE:
3111 case SYS_REFCURSOR:
3112 case TABLE:
3113 case TEMPORARY:
3114 case THEN:
3115 case TIME:
3116 case TIMESTAMP:
3117 case TIMEZONE_REGION:
3118 case TIMEZONE_ABBR:
3119 case TIMEZONE_MINUTE:
3120 case TIMEZONE_HOUR:
3121 case TO:
3122 case TRANSACTION:
3123 case TRIGGER:
3124 case TRUE:
3125 case TYPE:
3126 case UI:
3127 case UNDER:
3128 case USING:
3129 case WHILE:
3130 case YES:
3131 case SHOW:
3132 case A:
3133 case UPDATE:
3134 case VARCHAR:
3135 case VARCHAR2:
3136 case DOUBLE:
3137 case DEC:
3138 case PRECISION:
3139 case INT:
3140 case NUMERIC:
3141 case SIGNTYPE:
3142 case NCHAR:
3143 case NVARCHAR2:
3144 case STRING:
3145 case UROWID:
3146 case VARRAY:
3147 case VARYING:
3148 case BFILE:
3149 case BLOB:
3150 case CLOB:
3151 case NCLOB:
3152 case YEAR:
3153 case LOCAL:
3154 case WITH:
3155 case ZONE:
3156 case CHARACTER:
3157 case AFTER:
3158 case BEFORE:
3159 case OLD:
3160 case PARENT:
3161 case CC_IF:
3162 case ANALYZE:
3163 case ASSOCIATE:
3164 case AUDIT:
3165 case COMPOUND:
3166 case DATABASE:
3167 case CALL:
3168 case DDL:
3169 case DISASSOCIATE:
3170 case EACH:
3171 case FOLLOWS:
3172 case LOGOFF:
3173 case LOGON:
3174 case NESTED:
3175 case NOAUDIT:
3176 case SCHEMA:
3177 case SERVERERROR:
3178 case SHUTDOWN:
3179 case STARTUP:
3180 case STATEMENT:
3181 case STATISTICS:
3182 case SUSPEND:
3183 case TRUNCATE:
3184 case WRAPPED:
3185 case LIBRARY:
3186 case NAME:
3187 case STRUCT:
3188 case CONTEXT:
3189 case PARAMETERS:
3190 case LENGTH:
3191 case TDO:
3192 case MAXLEN:
3193 case CHARSETID:
3194 case CHARSETFORM:
3195 case ACCEPT:
3196 case ACCESSIBLE:
3197 case COPY:
3198 case DEFINE:
3199 case DISCONNECT:
3200 case HOST:
3201 case PRINT:
3202 case QUIT:
3203 case REMARK:
3204 case UNDEFINE:
3205 case VARIABLE:
3206 case WHENEVER:
3207 case ATTACH:
3208 case CAST:
3209 case TREAT:
3210 case TRIM:
3211 case LEFT:
3212 case RIGHT:
3213 case BOTH:
3214 case EMPTY:
3215 case MULTISET:
3216 case SUBMULTISET:
3217 case LEADING:
3218 case TRAILING:
3219 case CHAR_CS:
3220 case NCHAR_CS:
3221 case DBTIMEZONE:
3222 case SESSIONTIMEZONE:
3223 case AUTHENTICATED:
3224 case LINK:
3225 case SHARED:
3226 case DIRECTORY:
3227 case USER:
3228 case IDENTIFIER:
3229 case QUOTED_LITERAL:
3230 case SQLDATA_CLASS:
3231 case CUSTOMDATUM_CLASS:
3232 case ORADATA_CLASS:
3233 case JAVA_INTERFACE_CLASS:
3234 DeclarativeUnit();
3235 break;
3236 case CC_ERROR:
3237 jj_consume_token(CC_ERROR);
3238 Expression();
3239 jj_consume_token(CC_END);
3240 break;
3241 default:
3242 jj_la1[35] = jj_gen;
3243 jj_consume_token(-1);
3244 throw new ParseException();
3245 }
3246 }
3247 label_9:
3248 while (true) {
3249 switch (jj_nt.kind) {
3250 case CC_ELSIF:
3251 ;
3252 break;
3253 default:
3254 jj_la1[36] = jj_gen;
3255 break label_9;
3256 }
3257 jj_consume_token(CC_ELSIF);
3258 ConditionalOrExpression();
3259 jj_consume_token(CC_THEN);
3260 label_10:
3261 while (true) {
3262 switch (jj_nt.kind) {
3263 case REPLACE:
3264 case DEFINER:
3265 case CURRENT_USER:
3266 case SERIALLY_REUSABLE:
3267 case RESTRICT_REFERENCES:
3268 case EXCEPTION_INIT:
3269 case AUTONOMOUS_TRANSACTION:
3270 case LANGUAGE:
3271 case INLINE:
3272 case ADD:
3273 case AGGREGATE:
3274 case ALL:
3275 case ALTER:
3276 case AND:
3277 case ANY:
3278 case ARRAY:
3279 case AS:
3280 case ASC:
3281 case AT:
3282 case ATTRIBUTE:
3283 case AUTHID:
3284 case AVG:
3285 case BETWEEN:
3286 case BINARY_INTEGER:
3287 case BODY:
3288 case BOOLEAN:
3289 case BULK:
3290 case BY:
3291 case BYTE:
3292 case CASCADE:
3293 case CASE:
3294 case CHAR:
3295 case CHAR_BASE:
3296 case CHECK:
3297 case CLOSE:
3298 case CLUSTER:
3299 case COALESCE:
3300 case COLLECT:
3301 case COLUMN:
3302 case COMMENT:
3303 case COMMIT:
3304 case COMPRESS:
3305 case CONNECT:
3306 case CONSTANT:
3307 case CONSTRUCTOR:
3308 case CONTINUE:
3309 case CONVERT:
3310 case CREATE:
3311 case CURRENT:
3312 case CURRVAL:
3313 case CURSOR:
3314 case DATA:
3315 case DATE:
3316 case DAY:
3317 case DECLARE:
3318 case DECIMAL:
3319 case _DEFAULT:
3320 case DELETE:
3321 case DESC:
3322 case DISABLE:
3323 case DISTINCT:
3324 case DO:
3325 case DROP:
3326 case EDITIONABLE:
3327 case ELEMENT:
3328 case ELSE:
3329 case ELSIF:
3330 case ENABLE:
3331 case ESCAPE:
3332 case EXCEPT:
3333 case EXCEPTION:
3334 case EXCEPTIONS:
3335 case EXCLUSIVE:
3336 case EXECUTE:
3337 case EXISTS:
3338 case EXIT:
3339 case EXTERNAL:
3340 case EXTENDS:
3341 case EXTRACT:
3342 case FALSE:
3343 case FETCH:
3344 case FINAL:
3345 case FLOAT:
3346 case FOR:
3347 case FORALL:
3348 case FORCE:
3349 case FROM:
3350 case FUNCTION:
3351 case GLOBAL:
3352 case GOTO:
3353 case GROUP:
3354 case HASH:
3355 case HAVING:
3356 case HEAP:
3357 case HOUR:
3358 case IF:
3359 case IMMEDIATE:
3360 case IN:
3361 case INDEX:
3362 case INDICES:
3363 case INDEXTYPE:
3364 case INDICATOR:
3365 case INSERT:
3366 case INSTANTIABLE:
3367 case INTEGER:
3368 case INTERFACE:
3369 case INTERSECT:
3370 case INTERVAL:
3371 case INTO:
3372 case INVALIDATE:
3373 case IS:
3374 case ISOLATION:
3375 case JAVA:
3376 case LEVEL:
3377 case LIKE:
3378 case LIMIT:
3379 case LIMITED:
3380 case LOCK:
3381 case LONG:
3382 case LOOP:
3383 case MAP:
3384 case MAX:
3385 case MEMBER:
3386 case MERGE:
3387 case MIN:
3388 case MINUS:
3389 case MINUTE:
3390 case MLSLABEL:
3391 case MODIFY:
3392 case MOD:
3393 case MODE:
3394 case MONTH:
3395 case NATURAL:
3396 case NATURALN:
3397 case NEW:
3398 case NEXTVAL:
3399 case NO:
3400 case NOCOPY:
3401 case NONEDITIONABLE:
3402 case NOT:
3403 case NOWAIT:
3404 case NULL:
3405 case NULLIF:
3406 case NUMBER:
3407 case BFILE_BASE:
3408 case BLOB_BASE:
3409 case CLOB_BASE:
3410 case DATE_BASE:
3411 case NUMBER_BASE:
3412 case OBJECT:
3413 case OCIROWID:
3414 case OF:
3415 case OID:
3416 case ON:
3417 case OPAQUE:
3418 case OPEN:
3419 case OPERATOR:
3420 case OPTION:
3421 case OR:
3422 case ORDER:
3423 case ORGANIZATION:
3424 case OTHERS:
3425 case OUT:
3426 case OVERRIDING:
3427 case PACKAGE:
3428 case PARTITION:
3429 case PCTFREE:
3430 case PLS_INTEGER:
3431 case POSITIVE:
3432 case POSITIVEN:
3433 case PRAGMA:
3434 case PRESERVE:
3435 case PRIOR:
3436 case PROMPT:
3437 case PRIVATE:
3438 case PROCEDURE:
3439 case PUBLIC:
3440 case RAISE:
3441 case RANGE:
3442 case RAW:
3443 case REAL:
3444 case RECORD:
3445 case REF:
3446 case RELEASE:
3447 case RELIES_ON:
3448 case RENAME:
3449 case RESULT:
3450 case RETURN:
3451 case RETURNING:
3452 case REVERSE:
3453 case ROLLBACK:
3454 case ROW:
3455 case ROWS:
3456 case ROWID:
3457 case ROWNUM:
3458 case ROWTYPE:
3459 case SAVE:
3460 case SAVEPOINT:
3461 case SECOND:
3462 case SELECT:
3463 case SELF:
3464 case SEPARATE:
3465 case SET:
3466 case SHARE:
3467 case SMALLINT:
3468 case SPACE:
3469 case SQL:
3470 case SQLCODE:
3471 case SQLERRM:
3472 case START:
3473 case STATIC:
3474 case STDDEV:
3475 case SUBTYPE:
3476 case SUBSTITUTABLE:
3477 case SUCCESSFUL:
3478 case SUM:
3479 case SYNONYM:
3480 case SYSDATE:
3481 case SYS_REFCURSOR:
3482 case TABLE:
3483 case TEMPORARY:
3484 case THEN:
3485 case TIME:
3486 case TIMESTAMP:
3487 case TIMEZONE_REGION:
3488 case TIMEZONE_ABBR:
3489 case TIMEZONE_MINUTE:
3490 case TIMEZONE_HOUR:
3491 case TO:
3492 case TRANSACTION:
3493 case TRIGGER:
3494 case TRUE:
3495 case TYPE:
3496 case UI:
3497 case UNDER:
3498 case USING:
3499 case WHILE:
3500 case YES:
3501 case SHOW:
3502 case A:
3503 case UPDATE:
3504 case VARCHAR:
3505 case VARCHAR2:
3506 case DOUBLE:
3507 case DEC:
3508 case PRECISION:
3509 case INT:
3510 case NUMERIC:
3511 case SIGNTYPE:
3512 case NCHAR:
3513 case NVARCHAR2:
3514 case STRING:
3515 case UROWID:
3516 case VARRAY:
3517 case VARYING:
3518 case BFILE:
3519 case BLOB:
3520 case CLOB:
3521 case NCLOB:
3522 case YEAR:
3523 case LOCAL:
3524 case WITH:
3525 case ZONE:
3526 case CHARACTER:
3527 case AFTER:
3528 case BEFORE:
3529 case OLD:
3530 case PARENT:
3531 case CC_IF:
3532 case CC_ERROR:
3533 case ANALYZE:
3534 case ASSOCIATE:
3535 case AUDIT:
3536 case COMPOUND:
3537 case DATABASE:
3538 case CALL:
3539 case DDL:
3540 case DISASSOCIATE:
3541 case EACH:
3542 case FOLLOWS:
3543 case LOGOFF:
3544 case LOGON:
3545 case NESTED:
3546 case NOAUDIT:
3547 case SCHEMA:
3548 case SERVERERROR:
3549 case SHUTDOWN:
3550 case STARTUP:
3551 case STATEMENT:
3552 case STATISTICS:
3553 case SUSPEND:
3554 case TRUNCATE:
3555 case WRAPPED:
3556 case LIBRARY:
3557 case NAME:
3558 case STRUCT:
3559 case CONTEXT:
3560 case PARAMETERS:
3561 case LENGTH:
3562 case TDO:
3563 case MAXLEN:
3564 case CHARSETID:
3565 case CHARSETFORM:
3566 case ACCEPT:
3567 case ACCESSIBLE:
3568 case COPY:
3569 case DEFINE:
3570 case DISCONNECT:
3571 case HOST:
3572 case PRINT:
3573 case QUIT:
3574 case REMARK:
3575 case UNDEFINE:
3576 case VARIABLE:
3577 case WHENEVER:
3578 case ATTACH:
3579 case CAST:
3580 case TREAT:
3581 case TRIM:
3582 case LEFT:
3583 case RIGHT:
3584 case BOTH:
3585 case EMPTY:
3586 case MULTISET:
3587 case SUBMULTISET:
3588 case LEADING:
3589 case TRAILING:
3590 case CHAR_CS:
3591 case NCHAR_CS:
3592 case DBTIMEZONE:
3593 case SESSIONTIMEZONE:
3594 case AUTHENTICATED:
3595 case LINK:
3596 case SHARED:
3597 case DIRECTORY:
3598 case USER:
3599 case IDENTIFIER:
3600 case QUOTED_LITERAL:
3601 case SQLDATA_CLASS:
3602 case CUSTOMDATUM_CLASS:
3603 case ORADATA_CLASS:
3604 case JAVA_INTERFACE_CLASS:
3605 ;
3606 break;
3607 default:
3608 jj_la1[37] = jj_gen;
3609 break label_10;
3610 }
3611 switch (jj_nt.kind) {
3612 case REPLACE:
3613 case DEFINER:
3614 case CURRENT_USER:
3615 case SERIALLY_REUSABLE:
3616 case RESTRICT_REFERENCES:
3617 case EXCEPTION_INIT:
3618 case AUTONOMOUS_TRANSACTION:
3619 case LANGUAGE:
3620 case INLINE:
3621 case ADD:
3622 case AGGREGATE:
3623 case ALL:
3624 case ALTER:
3625 case AND:
3626 case ANY:
3627 case ARRAY:
3628 case AS:
3629 case ASC:
3630 case AT:
3631 case ATTRIBUTE:
3632 case AUTHID:
3633 case AVG:
3634 case BETWEEN:
3635 case BINARY_INTEGER:
3636 case BODY:
3637 case BOOLEAN:
3638 case BULK:
3639 case BY:
3640 case BYTE:
3641 case CASCADE:
3642 case CASE:
3643 case CHAR:
3644 case CHAR_BASE:
3645 case CHECK:
3646 case CLOSE:
3647 case CLUSTER:
3648 case COALESCE:
3649 case COLLECT:
3650 case COLUMN:
3651 case COMMENT:
3652 case COMMIT:
3653 case COMPRESS:
3654 case CONNECT:
3655 case CONSTANT:
3656 case CONSTRUCTOR:
3657 case CONTINUE:
3658 case CONVERT:
3659 case CREATE:
3660 case CURRENT:
3661 case CURRVAL:
3662 case CURSOR:
3663 case DATA:
3664 case DATE:
3665 case DAY:
3666 case DECLARE:
3667 case DECIMAL:
3668 case _DEFAULT:
3669 case DELETE:
3670 case DESC:
3671 case DISABLE:
3672 case DISTINCT:
3673 case DO:
3674 case DROP:
3675 case EDITIONABLE:
3676 case ELEMENT:
3677 case ELSE:
3678 case ELSIF:
3679 case ENABLE:
3680 case ESCAPE:
3681 case EXCEPT:
3682 case EXCEPTION:
3683 case EXCEPTIONS:
3684 case EXCLUSIVE:
3685 case EXECUTE:
3686 case EXISTS:
3687 case EXIT:
3688 case EXTERNAL:
3689 case EXTENDS:
3690 case EXTRACT:
3691 case FALSE:
3692 case FETCH:
3693 case FINAL:
3694 case FLOAT:
3695 case FOR:
3696 case FORALL:
3697 case FORCE:
3698 case FROM:
3699 case FUNCTION:
3700 case GLOBAL:
3701 case GOTO:
3702 case GROUP:
3703 case HASH:
3704 case HAVING:
3705 case HEAP:
3706 case HOUR:
3707 case IF:
3708 case IMMEDIATE:
3709 case IN:
3710 case INDEX:
3711 case INDICES:
3712 case INDEXTYPE:
3713 case INDICATOR:
3714 case INSERT:
3715 case INSTANTIABLE:
3716 case INTEGER:
3717 case INTERFACE:
3718 case INTERSECT:
3719 case INTERVAL:
3720 case INTO:
3721 case INVALIDATE:
3722 case IS:
3723 case ISOLATION:
3724 case JAVA:
3725 case LEVEL:
3726 case LIKE:
3727 case LIMIT:
3728 case LIMITED:
3729 case LOCK:
3730 case LONG:
3731 case LOOP:
3732 case MAP:
3733 case MAX:
3734 case MEMBER:
3735 case MERGE:
3736 case MIN:
3737 case MINUS:
3738 case MINUTE:
3739 case MLSLABEL:
3740 case MODIFY:
3741 case MOD:
3742 case MODE:
3743 case MONTH:
3744 case NATURAL:
3745 case NATURALN:
3746 case NEW:
3747 case NEXTVAL:
3748 case NO:
3749 case NOCOPY:
3750 case NONEDITIONABLE:
3751 case NOT:
3752 case NOWAIT:
3753 case NULL:
3754 case NULLIF:
3755 case NUMBER:
3756 case BFILE_BASE:
3757 case BLOB_BASE:
3758 case CLOB_BASE:
3759 case DATE_BASE:
3760 case NUMBER_BASE:
3761 case OBJECT:
3762 case OCIROWID:
3763 case OF:
3764 case OID:
3765 case ON:
3766 case OPAQUE:
3767 case OPEN:
3768 case OPERATOR:
3769 case OPTION:
3770 case OR:
3771 case ORDER:
3772 case ORGANIZATION:
3773 case OTHERS:
3774 case OUT:
3775 case OVERRIDING:
3776 case PACKAGE:
3777 case PARTITION:
3778 case PCTFREE:
3779 case PLS_INTEGER:
3780 case POSITIVE:
3781 case POSITIVEN:
3782 case PRAGMA:
3783 case PRESERVE:
3784 case PRIOR:
3785 case PROMPT:
3786 case PRIVATE:
3787 case PROCEDURE:
3788 case PUBLIC:
3789 case RAISE:
3790 case RANGE:
3791 case RAW:
3792 case REAL:
3793 case RECORD:
3794 case REF:
3795 case RELEASE:
3796 case RELIES_ON:
3797 case RENAME:
3798 case RESULT:
3799 case RETURN:
3800 case RETURNING:
3801 case REVERSE:
3802 case ROLLBACK:
3803 case ROW:
3804 case ROWS:
3805 case ROWID:
3806 case ROWNUM:
3807 case ROWTYPE:
3808 case SAVE:
3809 case SAVEPOINT:
3810 case SECOND:
3811 case SELECT:
3812 case SELF:
3813 case SEPARATE:
3814 case SET:
3815 case SHARE:
3816 case SMALLINT:
3817 case SPACE:
3818 case SQL:
3819 case SQLCODE:
3820 case SQLERRM:
3821 case START:
3822 case STATIC:
3823 case STDDEV:
3824 case SUBTYPE:
3825 case SUBSTITUTABLE:
3826 case SUCCESSFUL:
3827 case SUM:
3828 case SYNONYM:
3829 case SYSDATE:
3830 case SYS_REFCURSOR:
3831 case TABLE:
3832 case TEMPORARY:
3833 case THEN:
3834 case TIME:
3835 case TIMESTAMP:
3836 case TIMEZONE_REGION:
3837 case TIMEZONE_ABBR:
3838 case TIMEZONE_MINUTE:
3839 case TIMEZONE_HOUR:
3840 case TO:
3841 case TRANSACTION:
3842 case TRIGGER:
3843 case TRUE:
3844 case TYPE:
3845 case UI:
3846 case UNDER:
3847 case USING:
3848 case WHILE:
3849 case YES:
3850 case SHOW:
3851 case A:
3852 case UPDATE:
3853 case VARCHAR:
3854 case VARCHAR2:
3855 case DOUBLE:
3856 case DEC:
3857 case PRECISION:
3858 case INT:
3859 case NUMERIC:
3860 case SIGNTYPE:
3861 case NCHAR:
3862 case NVARCHAR2:
3863 case STRING:
3864 case UROWID:
3865 case VARRAY:
3866 case VARYING:
3867 case BFILE:
3868 case BLOB:
3869 case CLOB:
3870 case NCLOB:
3871 case YEAR:
3872 case LOCAL:
3873 case WITH:
3874 case ZONE:
3875 case CHARACTER:
3876 case AFTER:
3877 case BEFORE:
3878 case OLD:
3879 case PARENT:
3880 case CC_IF:
3881 case ANALYZE:
3882 case ASSOCIATE:
3883 case AUDIT:
3884 case COMPOUND:
3885 case DATABASE:
3886 case CALL:
3887 case DDL:
3888 case DISASSOCIATE:
3889 case EACH:
3890 case FOLLOWS:
3891 case LOGOFF:
3892 case LOGON:
3893 case NESTED:
3894 case NOAUDIT:
3895 case SCHEMA:
3896 case SERVERERROR:
3897 case SHUTDOWN:
3898 case STARTUP:
3899 case STATEMENT:
3900 case STATISTICS:
3901 case SUSPEND:
3902 case TRUNCATE:
3903 case WRAPPED:
3904 case LIBRARY:
3905 case NAME:
3906 case STRUCT:
3907 case CONTEXT:
3908 case PARAMETERS:
3909 case LENGTH:
3910 case TDO:
3911 case MAXLEN:
3912 case CHARSETID:
3913 case CHARSETFORM:
3914 case ACCEPT:
3915 case ACCESSIBLE:
3916 case COPY:
3917 case DEFINE:
3918 case DISCONNECT:
3919 case HOST:
3920 case PRINT:
3921 case QUIT:
3922 case REMARK:
3923 case UNDEFINE:
3924 case VARIABLE:
3925 case WHENEVER:
3926 case ATTACH:
3927 case CAST:
3928 case TREAT:
3929 case TRIM:
3930 case LEFT:
3931 case RIGHT:
3932 case BOTH:
3933 case EMPTY:
3934 case MULTISET:
3935 case SUBMULTISET:
3936 case LEADING:
3937 case TRAILING:
3938 case CHAR_CS:
3939 case NCHAR_CS:
3940 case DBTIMEZONE:
3941 case SESSIONTIMEZONE:
3942 case AUTHENTICATED:
3943 case LINK:
3944 case SHARED:
3945 case DIRECTORY:
3946 case USER:
3947 case IDENTIFIER:
3948 case QUOTED_LITERAL:
3949 case SQLDATA_CLASS:
3950 case CUSTOMDATUM_CLASS:
3951 case ORADATA_CLASS:
3952 case JAVA_INTERFACE_CLASS:
3953 DeclarativeUnit();
3954 break;
3955 case CC_ERROR:
3956 jj_consume_token(CC_ERROR);
3957 Expression();
3958 jj_consume_token(CC_END);
3959 break;
3960 default:
3961 jj_la1[38] = jj_gen;
3962 jj_consume_token(-1);
3963 throw new ParseException();
3964 }
3965 }
3966 }
3967 label_11:
3968 while (true) {
3969 switch (jj_nt.kind) {
3970 case CC_ELSE:
3971 ;
3972 break;
3973 default:
3974 jj_la1[39] = jj_gen;
3975 break label_11;
3976 }
3977 jj_consume_token(CC_ELSE);
3978 label_12:
3979 while (true) {
3980 switch (jj_nt.kind) {
3981 case REPLACE:
3982 case DEFINER:
3983 case CURRENT_USER:
3984 case SERIALLY_REUSABLE:
3985 case RESTRICT_REFERENCES:
3986 case EXCEPTION_INIT:
3987 case AUTONOMOUS_TRANSACTION:
3988 case LANGUAGE:
3989 case INLINE:
3990 case ADD:
3991 case AGGREGATE:
3992 case ALL:
3993 case ALTER:
3994 case AND:
3995 case ANY:
3996 case ARRAY:
3997 case AS:
3998 case ASC:
3999 case AT:
4000 case ATTRIBUTE:
4001 case AUTHID:
4002 case AVG:
4003 case BETWEEN:
4004 case BINARY_INTEGER:
4005 case BODY:
4006 case BOOLEAN:
4007 case BULK:
4008 case BY:
4009 case BYTE:
4010 case CASCADE:
4011 case CASE:
4012 case CHAR:
4013 case CHAR_BASE:
4014 case CHECK:
4015 case CLOSE:
4016 case CLUSTER:
4017 case COALESCE:
4018 case COLLECT:
4019 case COLUMN:
4020 case COMMENT:
4021 case COMMIT:
4022 case COMPRESS:
4023 case CONNECT:
4024 case CONSTANT:
4025 case CONSTRUCTOR:
4026 case CONTINUE:
4027 case CONVERT:
4028 case CREATE:
4029 case CURRENT:
4030 case CURRVAL:
4031 case CURSOR:
4032 case DATA:
4033 case DATE:
4034 case DAY:
4035 case DECLARE:
4036 case DECIMAL:
4037 case _DEFAULT:
4038 case DELETE:
4039 case DESC:
4040 case DISABLE:
4041 case DISTINCT:
4042 case DO:
4043 case DROP:
4044 case EDITIONABLE:
4045 case ELEMENT:
4046 case ELSE:
4047 case ELSIF:
4048 case ENABLE:
4049 case ESCAPE:
4050 case EXCEPT:
4051 case EXCEPTION:
4052 case EXCEPTIONS:
4053 case EXCLUSIVE:
4054 case EXECUTE:
4055 case EXISTS:
4056 case EXIT:
4057 case EXTERNAL:
4058 case EXTENDS:
4059 case EXTRACT:
4060 case FALSE:
4061 case FETCH:
4062 case FINAL:
4063 case FLOAT:
4064 case FOR:
4065 case FORALL:
4066 case FORCE:
4067 case FROM:
4068 case FUNCTION:
4069 case GLOBAL:
4070 case GOTO:
4071 case GROUP:
4072 case HASH:
4073 case HAVING:
4074 case HEAP:
4075 case HOUR:
4076 case IF:
4077 case IMMEDIATE:
4078 case IN:
4079 case INDEX:
4080 case INDICES:
4081 case INDEXTYPE:
4082 case INDICATOR:
4083 case INSERT:
4084 case INSTANTIABLE:
4085 case INTEGER:
4086 case INTERFACE:
4087 case INTERSECT:
4088 case INTERVAL:
4089 case INTO:
4090 case INVALIDATE:
4091 case IS:
4092 case ISOLATION:
4093 case JAVA:
4094 case LEVEL:
4095 case LIKE:
4096 case LIMIT:
4097 case LIMITED:
4098 case LOCK:
4099 case LONG:
4100 case LOOP:
4101 case MAP:
4102 case MAX:
4103 case MEMBER:
4104 case MERGE:
4105 case MIN:
4106 case MINUS:
4107 case MINUTE:
4108 case MLSLABEL:
4109 case MODIFY:
4110 case MOD:
4111 case MODE:
4112 case MONTH:
4113 case NATURAL:
4114 case NATURALN:
4115 case NEW:
4116 case NEXTVAL:
4117 case NO:
4118 case NOCOPY:
4119 case NONEDITIONABLE:
4120 case NOT:
4121 case NOWAIT:
4122 case NULL:
4123 case NULLIF:
4124 case NUMBER:
4125 case BFILE_BASE:
4126 case BLOB_BASE:
4127 case CLOB_BASE:
4128 case DATE_BASE:
4129 case NUMBER_BASE:
4130 case OBJECT:
4131 case OCIROWID:
4132 case OF:
4133 case OID:
4134 case ON:
4135 case OPAQUE:
4136 case OPEN:
4137 case OPERATOR:
4138 case OPTION:
4139 case OR:
4140 case ORDER:
4141 case ORGANIZATION:
4142 case OTHERS:
4143 case OUT:
4144 case OVERRIDING:
4145 case PACKAGE:
4146 case PARTITION:
4147 case PCTFREE:
4148 case PLS_INTEGER:
4149 case POSITIVE:
4150 case POSITIVEN:
4151 case PRAGMA:
4152 case PRESERVE:
4153 case PRIOR:
4154 case PROMPT:
4155 case PRIVATE:
4156 case PROCEDURE:
4157 case PUBLIC:
4158 case RAISE:
4159 case RANGE:
4160 case RAW:
4161 case REAL:
4162 case RECORD:
4163 case REF:
4164 case RELEASE:
4165 case RELIES_ON:
4166 case RENAME:
4167 case RESULT:
4168 case RETURN:
4169 case RETURNING:
4170 case REVERSE:
4171 case ROLLBACK:
4172 case ROW:
4173 case ROWS:
4174 case ROWID:
4175 case ROWNUM:
4176 case ROWTYPE:
4177 case SAVE:
4178 case SAVEPOINT:
4179 case SECOND:
4180 case SELECT:
4181 case SELF:
4182 case SEPARATE:
4183 case SET:
4184 case SHARE:
4185 case SMALLINT:
4186 case SPACE:
4187 case SQL:
4188 case SQLCODE:
4189 case SQLERRM:
4190 case START:
4191 case STATIC:
4192 case STDDEV:
4193 case SUBTYPE:
4194 case SUBSTITUTABLE:
4195 case SUCCESSFUL:
4196 case SUM:
4197 case SYNONYM:
4198 case SYSDATE:
4199 case SYS_REFCURSOR:
4200 case TABLE:
4201 case TEMPORARY:
4202 case THEN:
4203 case TIME:
4204 case TIMESTAMP:
4205 case TIMEZONE_REGION:
4206 case TIMEZONE_ABBR:
4207 case TIMEZONE_MINUTE:
4208 case TIMEZONE_HOUR:
4209 case TO:
4210 case TRANSACTION:
4211 case TRIGGER:
4212 case TRUE:
4213 case TYPE:
4214 case UI:
4215 case UNDER:
4216 case USING:
4217 case WHILE:
4218 case YES:
4219 case SHOW:
4220 case A:
4221 case UPDATE:
4222 case VARCHAR:
4223 case VARCHAR2:
4224 case DOUBLE:
4225 case DEC:
4226 case PRECISION:
4227 case INT:
4228 case NUMERIC:
4229 case SIGNTYPE:
4230 case NCHAR:
4231 case NVARCHAR2:
4232 case STRING:
4233 case UROWID:
4234 case VARRAY:
4235 case VARYING:
4236 case BFILE:
4237 case BLOB:
4238 case CLOB:
4239 case NCLOB:
4240 case YEAR:
4241 case LOCAL:
4242 case WITH:
4243 case ZONE:
4244 case CHARACTER:
4245 case AFTER:
4246 case BEFORE:
4247 case OLD:
4248 case PARENT:
4249 case CC_IF:
4250 case CC_ERROR:
4251 case ANALYZE:
4252 case ASSOCIATE:
4253 case AUDIT:
4254 case COMPOUND:
4255 case DATABASE:
4256 case CALL:
4257 case DDL:
4258 case DISASSOCIATE:
4259 case EACH:
4260 case FOLLOWS:
4261 case LOGOFF:
4262 case LOGON:
4263 case NESTED:
4264 case NOAUDIT:
4265 case SCHEMA:
4266 case SERVERERROR:
4267 case SHUTDOWN:
4268 case STARTUP:
4269 case STATEMENT:
4270 case STATISTICS:
4271 case SUSPEND:
4272 case TRUNCATE:
4273 case WRAPPED:
4274 case LIBRARY:
4275 case NAME:
4276 case STRUCT:
4277 case CONTEXT:
4278 case PARAMETERS:
4279 case LENGTH:
4280 case TDO:
4281 case MAXLEN:
4282 case CHARSETID:
4283 case CHARSETFORM:
4284 case ACCEPT:
4285 case ACCESSIBLE:
4286 case COPY:
4287 case DEFINE:
4288 case DISCONNECT:
4289 case HOST:
4290 case PRINT:
4291 case QUIT:
4292 case REMARK:
4293 case UNDEFINE:
4294 case VARIABLE:
4295 case WHENEVER:
4296 case ATTACH:
4297 case CAST:
4298 case TREAT:
4299 case TRIM:
4300 case LEFT:
4301 case RIGHT:
4302 case BOTH:
4303 case EMPTY:
4304 case MULTISET:
4305 case SUBMULTISET:
4306 case LEADING:
4307 case TRAILING:
4308 case CHAR_CS:
4309 case NCHAR_CS:
4310 case DBTIMEZONE:
4311 case SESSIONTIMEZONE:
4312 case AUTHENTICATED:
4313 case LINK:
4314 case SHARED:
4315 case DIRECTORY:
4316 case USER:
4317 case IDENTIFIER:
4318 case QUOTED_LITERAL:
4319 case SQLDATA_CLASS:
4320 case CUSTOMDATUM_CLASS:
4321 case ORADATA_CLASS:
4322 case JAVA_INTERFACE_CLASS:
4323 ;
4324 break;
4325 default:
4326 jj_la1[40] = jj_gen;
4327 break label_12;
4328 }
4329 switch (jj_nt.kind) {
4330 case REPLACE:
4331 case DEFINER:
4332 case CURRENT_USER:
4333 case SERIALLY_REUSABLE:
4334 case RESTRICT_REFERENCES:
4335 case EXCEPTION_INIT:
4336 case AUTONOMOUS_TRANSACTION:
4337 case LANGUAGE:
4338 case INLINE:
4339 case ADD:
4340 case AGGREGATE:
4341 case ALL:
4342 case ALTER:
4343 case AND:
4344 case ANY:
4345 case ARRAY:
4346 case AS:
4347 case ASC:
4348 case AT:
4349 case ATTRIBUTE:
4350 case AUTHID:
4351 case AVG:
4352 case BETWEEN:
4353 case BINARY_INTEGER:
4354 case BODY:
4355 case BOOLEAN:
4356 case BULK:
4357 case BY:
4358 case BYTE:
4359 case CASCADE:
4360 case CASE:
4361 case CHAR:
4362 case CHAR_BASE:
4363 case CHECK:
4364 case CLOSE:
4365 case CLUSTER:
4366 case COALESCE:
4367 case COLLECT:
4368 case COLUMN:
4369 case COMMENT:
4370 case COMMIT:
4371 case COMPRESS:
4372 case CONNECT:
4373 case CONSTANT:
4374 case CONSTRUCTOR:
4375 case CONTINUE:
4376 case CONVERT:
4377 case CREATE:
4378 case CURRENT:
4379 case CURRVAL:
4380 case CURSOR:
4381 case DATA:
4382 case DATE:
4383 case DAY:
4384 case DECLARE:
4385 case DECIMAL:
4386 case _DEFAULT:
4387 case DELETE:
4388 case DESC:
4389 case DISABLE:
4390 case DISTINCT:
4391 case DO:
4392 case DROP:
4393 case EDITIONABLE:
4394 case ELEMENT:
4395 case ELSE:
4396 case ELSIF:
4397 case ENABLE:
4398 case ESCAPE:
4399 case EXCEPT:
4400 case EXCEPTION:
4401 case EXCEPTIONS:
4402 case EXCLUSIVE:
4403 case EXECUTE:
4404 case EXISTS:
4405 case EXIT:
4406 case EXTERNAL:
4407 case EXTENDS:
4408 case EXTRACT:
4409 case FALSE:
4410 case FETCH:
4411 case FINAL:
4412 case FLOAT:
4413 case FOR:
4414 case FORALL:
4415 case FORCE:
4416 case FROM:
4417 case FUNCTION:
4418 case GLOBAL:
4419 case GOTO:
4420 case GROUP:
4421 case HASH:
4422 case HAVING:
4423 case HEAP:
4424 case HOUR:
4425 case IF:
4426 case IMMEDIATE:
4427 case IN:
4428 case INDEX:
4429 case INDICES:
4430 case INDEXTYPE:
4431 case INDICATOR:
4432 case INSERT:
4433 case INSTANTIABLE:
4434 case INTEGER:
4435 case INTERFACE:
4436 case INTERSECT:
4437 case INTERVAL:
4438 case INTO:
4439 case INVALIDATE:
4440 case IS:
4441 case ISOLATION:
4442 case JAVA:
4443 case LEVEL:
4444 case LIKE:
4445 case LIMIT:
4446 case LIMITED:
4447 case LOCK:
4448 case LONG:
4449 case LOOP:
4450 case MAP:
4451 case MAX:
4452 case MEMBER:
4453 case MERGE:
4454 case MIN:
4455 case MINUS:
4456 case MINUTE:
4457 case MLSLABEL:
4458 case MODIFY:
4459 case MOD:
4460 case MODE:
4461 case MONTH:
4462 case NATURAL:
4463 case NATURALN:
4464 case NEW:
4465 case NEXTVAL:
4466 case NO:
4467 case NOCOPY:
4468 case NONEDITIONABLE:
4469 case NOT:
4470 case NOWAIT:
4471 case NULL:
4472 case NULLIF:
4473 case NUMBER:
4474 case BFILE_BASE:
4475 case BLOB_BASE:
4476 case CLOB_BASE:
4477 case DATE_BASE:
4478 case NUMBER_BASE:
4479 case OBJECT:
4480 case OCIROWID:
4481 case OF:
4482 case OID:
4483 case ON:
4484 case OPAQUE:
4485 case OPEN:
4486 case OPERATOR:
4487 case OPTION:
4488 case OR:
4489 case ORDER:
4490 case ORGANIZATION:
4491 case OTHERS:
4492 case OUT:
4493 case OVERRIDING:
4494 case PACKAGE:
4495 case PARTITION:
4496 case PCTFREE:
4497 case PLS_INTEGER:
4498 case POSITIVE:
4499 case POSITIVEN:
4500 case PRAGMA:
4501 case PRESERVE:
4502 case PRIOR:
4503 case PROMPT:
4504 case PRIVATE:
4505 case PROCEDURE:
4506 case PUBLIC:
4507 case RAISE:
4508 case RANGE:
4509 case RAW:
4510 case REAL:
4511 case RECORD:
4512 case REF:
4513 case RELEASE:
4514 case RELIES_ON:
4515 case RENAME:
4516 case RESULT:
4517 case RETURN:
4518 case RETURNING:
4519 case REVERSE:
4520 case ROLLBACK:
4521 case ROW:
4522 case ROWS:
4523 case ROWID:
4524 case ROWNUM:
4525 case ROWTYPE:
4526 case SAVE:
4527 case SAVEPOINT:
4528 case SECOND:
4529 case SELECT:
4530 case SELF:
4531 case SEPARATE:
4532 case SET:
4533 case SHARE:
4534 case SMALLINT:
4535 case SPACE:
4536 case SQL:
4537 case SQLCODE:
4538 case SQLERRM:
4539 case START:
4540 case STATIC:
4541 case STDDEV:
4542 case SUBTYPE:
4543 case SUBSTITUTABLE:
4544 case SUCCESSFUL:
4545 case SUM:
4546 case SYNONYM:
4547 case SYSDATE:
4548 case SYS_REFCURSOR:
4549 case TABLE:
4550 case TEMPORARY:
4551 case THEN:
4552 case TIME:
4553 case TIMESTAMP:
4554 case TIMEZONE_REGION:
4555 case TIMEZONE_ABBR:
4556 case TIMEZONE_MINUTE:
4557 case TIMEZONE_HOUR:
4558 case TO:
4559 case TRANSACTION:
4560 case TRIGGER:
4561 case TRUE:
4562 case TYPE:
4563 case UI:
4564 case UNDER:
4565 case USING:
4566 case WHILE:
4567 case YES:
4568 case SHOW:
4569 case A:
4570 case UPDATE:
4571 case VARCHAR:
4572 case VARCHAR2:
4573 case DOUBLE:
4574 case DEC:
4575 case PRECISION:
4576 case INT:
4577 case NUMERIC:
4578 case SIGNTYPE:
4579 case NCHAR:
4580 case NVARCHAR2:
4581 case STRING:
4582 case UROWID:
4583 case VARRAY:
4584 case VARYING:
4585 case BFILE:
4586 case BLOB:
4587 case CLOB:
4588 case NCLOB:
4589 case YEAR:
4590 case LOCAL:
4591 case WITH:
4592 case ZONE:
4593 case CHARACTER:
4594 case AFTER:
4595 case BEFORE:
4596 case OLD:
4597 case PARENT:
4598 case CC_IF:
4599 case ANALYZE:
4600 case ASSOCIATE:
4601 case AUDIT:
4602 case COMPOUND:
4603 case DATABASE:
4604 case CALL:
4605 case DDL:
4606 case DISASSOCIATE:
4607 case EACH:
4608 case FOLLOWS:
4609 case LOGOFF:
4610 case LOGON:
4611 case NESTED:
4612 case NOAUDIT:
4613 case SCHEMA:
4614 case SERVERERROR:
4615 case SHUTDOWN:
4616 case STARTUP:
4617 case STATEMENT:
4618 case STATISTICS:
4619 case SUSPEND:
4620 case TRUNCATE:
4621 case WRAPPED:
4622 case LIBRARY:
4623 case NAME:
4624 case STRUCT:
4625 case CONTEXT:
4626 case PARAMETERS:
4627 case LENGTH:
4628 case TDO:
4629 case MAXLEN:
4630 case CHARSETID:
4631 case CHARSETFORM:
4632 case ACCEPT:
4633 case ACCESSIBLE:
4634 case COPY:
4635 case DEFINE:
4636 case DISCONNECT:
4637 case HOST:
4638 case PRINT:
4639 case QUIT:
4640 case REMARK:
4641 case UNDEFINE:
4642 case VARIABLE:
4643 case WHENEVER:
4644 case ATTACH:
4645 case CAST:
4646 case TREAT:
4647 case TRIM:
4648 case LEFT:
4649 case RIGHT:
4650 case BOTH:
4651 case EMPTY:
4652 case MULTISET:
4653 case SUBMULTISET:
4654 case LEADING:
4655 case TRAILING:
4656 case CHAR_CS:
4657 case NCHAR_CS:
4658 case DBTIMEZONE:
4659 case SESSIONTIMEZONE:
4660 case AUTHENTICATED:
4661 case LINK:
4662 case SHARED:
4663 case DIRECTORY:
4664 case USER:
4665 case IDENTIFIER:
4666 case QUOTED_LITERAL:
4667 case SQLDATA_CLASS:
4668 case CUSTOMDATUM_CLASS:
4669 case ORADATA_CLASS:
4670 case JAVA_INTERFACE_CLASS:
4671 DeclarativeUnit();
4672 break;
4673 case CC_ERROR:
4674 jj_consume_token(CC_ERROR);
4675 Expression();
4676 jj_consume_token(CC_END);
4677 break;
4678 default:
4679 jj_la1[41] = jj_gen;
4680 jj_consume_token(-1);
4681 throw new ParseException();
4682 }
4683 }
4684 }
4685 jj_consume_token(CC_END);
4686 jjtree.closeNodeScope(jjtn000, true);
4687 jjtc000 = false;
4688 {if (true) return jjtn000 ;}
4689 } catch (Throwable jjte000) {
4690 if (jjtc000) {
4691 jjtree.clearNodeScope(jjtn000);
4692 jjtc000 = false;
4693 } else {
4694 jjtree.popNode();
4695 }
4696 if (jjte000 instanceof RuntimeException) {
4697 {if (true) throw (RuntimeException)jjte000;}
4698 }
4699 if (jjte000 instanceof ParseException) {
4700 {if (true) throw (ParseException)jjte000;}
4701 }
4702 {if (true) throw (Error)jjte000;}
4703 } finally {
4704 if (jjtc000) {
4705 jjtree.closeNodeScope(jjtn000, true);
4706 }
4707 }
4708 throw new Error("Missing return statement in function");
4709 }
4710
4711
4712
4713
4714
4715
4716
4717 final public ASTProgramUnit ProgramUnit() throws ParseException {
4718
4719 ASTProgramUnit jjtn000 = new ASTProgramUnit(this, JJTPROGRAMUNIT);
4720 boolean jjtc000 = true;
4721 jjtree.openNodeScope(jjtn000);
4722 try {
4723 switch (jj_nt.kind) {
4724 case CREATE:
4725 jj_consume_token(CREATE);
4726 switch (jj_nt.kind) {
4727 case OR:
4728 jj_consume_token(OR);
4729 jj_consume_token(REPLACE);
4730 break;
4731 default:
4732 jj_la1[42] = jj_gen;
4733 ;
4734 }
4735 switch (jj_nt.kind) {
4736 case EDITIONABLE:
4737 case NONEDITIONABLE:
4738 switch (jj_nt.kind) {
4739 case EDITIONABLE:
4740 jj_consume_token(EDITIONABLE);
4741 break;
4742 case NONEDITIONABLE:
4743 jj_consume_token(NONEDITIONABLE);
4744 break;
4745 default:
4746 jj_la1[43] = jj_gen;
4747 jj_consume_token(-1);
4748 throw new ParseException();
4749 }
4750 break;
4751 default:
4752 jj_la1[44] = jj_gen;
4753 ;
4754 }
4755 break;
4756 default:
4757 jj_la1[45] = jj_gen;
4758 ;
4759 }
4760 MethodDeclarator();
4761 switch (jj_nt.kind) {
4762 case WRAPPED:
4763 WrappedObject();
4764 break;
4765 case 4:
4766 case AGGREGATE:
4767 case AS:
4768 case AUTHID:
4769 case DETERMINISTIC:
4770 case IS:
4771 case PARALLEL_ENABLE:
4772 case PIPELINED:
4773 case RESULT_CACHE:
4774 case ACCESSIBLE:
4775 label_13:
4776 while (true) {
4777 switch (jj_nt.kind) {
4778 case AUTHID:
4779 case DETERMINISTIC:
4780 case PARALLEL_ENABLE:
4781 case PIPELINED:
4782 case RESULT_CACHE:
4783 case ACCESSIBLE:
4784 ;
4785 break;
4786 default:
4787 jj_la1[46] = jj_gen;
4788 break label_13;
4789 }
4790 switch (jj_nt.kind) {
4791 case AUTHID:
4792 jj_consume_token(AUTHID);
4793 switch (jj_nt.kind) {
4794 case CURRENT_USER:
4795 jj_consume_token(CURRENT_USER);
4796 break;
4797 case DEFINER:
4798 jj_consume_token(DEFINER);
4799 break;
4800 default:
4801 jj_la1[47] = jj_gen;
4802 jj_consume_token(-1);
4803 throw new ParseException();
4804 }
4805 break;
4806 case DETERMINISTIC:
4807 jj_consume_token(DETERMINISTIC);
4808 break;
4809 case ACCESSIBLE:
4810 AccessibleByClause();
4811 break;
4812 case PARALLEL_ENABLE:
4813 jj_consume_token(PARALLEL_ENABLE);
4814 switch (jj_nt.kind) {
4815 case 5:
4816 ParallelClause();
4817 break;
4818 default:
4819 jj_la1[48] = jj_gen;
4820 ;
4821 }
4822 switch (jj_nt.kind) {
4823 case USING:
4824 jj_consume_token(USING);
4825 ID();
4826 switch (jj_nt.kind) {
4827 case 3:
4828 jj_consume_token(3);
4829 ID();
4830 break;
4831 default:
4832 jj_la1[49] = jj_gen;
4833 ;
4834 }
4835 break;
4836 default:
4837 jj_la1[50] = jj_gen;
4838 ;
4839 }
4840 break;
4841 case PIPELINED:
4842 jj_consume_token(PIPELINED);
4843 switch (jj_nt.kind) {
4844 case CLUSTER:
4845 case ORDER:
4846 case USING:
4847 switch (jj_nt.kind) {
4848 case USING:
4849 jj_consume_token(USING);
4850 ID();
4851 switch (jj_nt.kind) {
4852 case 3:
4853 jj_consume_token(3);
4854 ID();
4855 break;
4856 default:
4857 jj_la1[51] = jj_gen;
4858 ;
4859 }
4860 break;
4861 case CLUSTER:
4862 case ORDER:
4863 switch (jj_nt.kind) {
4864 case ORDER:
4865 jj_consume_token(ORDER);
4866 break;
4867 case CLUSTER:
4868 jj_consume_token(CLUSTER);
4869 break;
4870 default:
4871 jj_la1[52] = jj_gen;
4872 jj_consume_token(-1);
4873 throw new ParseException();
4874 }
4875 switch (jj_nt.kind) {
4876 case REPLACE:
4877 case DEFINER:
4878 case CURRENT_USER:
4879 case SERIALLY_REUSABLE:
4880 case RESTRICT_REFERENCES:
4881 case EXCEPTION_INIT:
4882 case AUTONOMOUS_TRANSACTION:
4883 case LANGUAGE:
4884 case INLINE:
4885 case ADD:
4886 case AGGREGATE:
4887 case ALL:
4888 case ALTER:
4889 case AND:
4890 case ANY:
4891 case ARRAY:
4892 case AS:
4893 case ASC:
4894 case AT:
4895 case ATTRIBUTE:
4896 case AUTHID:
4897 case AVG:
4898 case BETWEEN:
4899 case BINARY_INTEGER:
4900 case BODY:
4901 case BOOLEAN:
4902 case BULK:
4903 case BY:
4904 case BYTE:
4905 case CASCADE:
4906 case CASE:
4907 case CHAR:
4908 case CHAR_BASE:
4909 case CHECK:
4910 case CLOSE:
4911 case CLUSTER:
4912 case COALESCE:
4913 case COLLECT:
4914 case COLUMN:
4915 case COMMENT:
4916 case COMMIT:
4917 case COMPRESS:
4918 case CONNECT:
4919 case CONSTANT:
4920 case CONSTRUCTOR:
4921 case CONTINUE:
4922 case CONVERT:
4923 case CREATE:
4924 case CURRENT:
4925 case CURRVAL:
4926 case CURSOR:
4927 case DATA:
4928 case DATE:
4929 case DAY:
4930 case DECLARE:
4931 case DECIMAL:
4932 case _DEFAULT:
4933 case DELETE:
4934 case DESC:
4935 case DISABLE:
4936 case DISTINCT:
4937 case DO:
4938 case DROP:
4939 case EDITIONABLE:
4940 case ELEMENT:
4941 case ELSE:
4942 case ELSIF:
4943 case ENABLE:
4944 case ESCAPE:
4945 case EXCEPT:
4946 case EXCEPTION:
4947 case EXCEPTIONS:
4948 case EXCLUSIVE:
4949 case EXECUTE:
4950 case EXISTS:
4951 case EXIT:
4952 case EXTERNAL:
4953 case EXTENDS:
4954 case EXTRACT:
4955 case FALSE:
4956 case FETCH:
4957 case FINAL:
4958 case FLOAT:
4959 case FOR:
4960 case FORALL:
4961 case FORCE:
4962 case FROM:
4963 case FUNCTION:
4964 case GLOBAL:
4965 case GOTO:
4966 case GROUP:
4967 case HASH:
4968 case HAVING:
4969 case HEAP:
4970 case HOUR:
4971 case IF:
4972 case IMMEDIATE:
4973 case IN:
4974 case INDEX:
4975 case INDICES:
4976 case INDEXTYPE:
4977 case INDICATOR:
4978 case INSERT:
4979 case INSTANTIABLE:
4980 case INTEGER:
4981 case INTERFACE:
4982 case INTERSECT:
4983 case INTERVAL:
4984 case INTO:
4985 case INVALIDATE:
4986 case IS:
4987 case ISOLATION:
4988 case JAVA:
4989 case LEVEL:
4990 case LIKE:
4991 case LIMIT:
4992 case LIMITED:
4993 case LOCK:
4994 case LONG:
4995 case LOOP:
4996 case MAP:
4997 case MAX:
4998 case MEMBER:
4999 case MERGE:
5000 case MIN:
5001 case MINUS:
5002 case MINUTE:
5003 case MLSLABEL:
5004 case MODIFY:
5005 case MOD:
5006 case MODE:
5007 case MONTH:
5008 case NATURAL:
5009 case NATURALN:
5010 case NEW:
5011 case NEXTVAL:
5012 case NO:
5013 case NOCOPY:
5014 case NONEDITIONABLE:
5015 case NOT:
5016 case NOWAIT:
5017 case NULL:
5018 case NULLIF:
5019 case NUMBER:
5020 case BFILE_BASE:
5021 case BLOB_BASE:
5022 case CLOB_BASE:
5023 case DATE_BASE:
5024 case NUMBER_BASE:
5025 case OBJECT:
5026 case OCIROWID:
5027 case OF:
5028 case OID:
5029 case ON:
5030 case OPAQUE:
5031 case OPEN:
5032 case OPERATOR:
5033 case OPTION:
5034 case OR:
5035 case ORDER:
5036 case ORGANIZATION:
5037 case OTHERS:
5038 case OUT:
5039 case OVERRIDING:
5040 case PACKAGE:
5041 case PARTITION:
5042 case PCTFREE:
5043 case PLS_INTEGER:
5044 case POSITIVE:
5045 case POSITIVEN:
5046 case PRESERVE:
5047 case PRIOR:
5048 case PROMPT:
5049 case PRIVATE:
5050 case PROCEDURE:
5051 case PUBLIC:
5052 case RAISE:
5053 case RANGE:
5054 case RAW:
5055 case REAL:
5056 case RECORD:
5057 case REF:
5058 case RELEASE:
5059 case RELIES_ON:
5060 case RENAME:
5061 case RESULT:
5062 case RETURN:
5063 case RETURNING:
5064 case REVERSE:
5065 case ROLLBACK:
5066 case ROW:
5067 case ROWS:
5068 case ROWID:
5069 case ROWNUM:
5070 case ROWTYPE:
5071 case SAVE:
5072 case SAVEPOINT:
5073 case SECOND:
5074 case SELECT:
5075 case SELF:
5076 case SEPARATE:
5077 case SET:
5078 case SHARE:
5079 case SMALLINT:
5080 case SPACE:
5081 case SQL:
5082 case SQLCODE:
5083 case SQLERRM:
5084 case START:
5085 case STATIC:
5086 case STDDEV:
5087 case SUBTYPE:
5088 case SUBSTITUTABLE:
5089 case SUCCESSFUL:
5090 case SUM:
5091 case SYNONYM:
5092 case SYSDATE:
5093 case SYS_REFCURSOR:
5094 case TABLE:
5095 case TEMPORARY:
5096 case THEN:
5097 case TIME:
5098 case TIMESTAMP:
5099 case TIMEZONE_REGION:
5100 case TIMEZONE_ABBR:
5101 case TIMEZONE_MINUTE:
5102 case TIMEZONE_HOUR:
5103 case TO:
5104 case TRANSACTION:
5105 case TRIGGER:
5106 case TRUE:
5107 case TYPE:
5108 case UI:
5109 case UNDER:
5110 case USING:
5111 case WHILE:
5112 case YES:
5113 case SHOW:
5114 case A:
5115 case UPDATE:
5116 case VARCHAR:
5117 case VARCHAR2:
5118 case DOUBLE:
5119 case DEC:
5120 case PRECISION:
5121 case INT:
5122 case NUMERIC:
5123 case SIGNTYPE:
5124 case NCHAR:
5125 case NVARCHAR2:
5126 case STRING:
5127 case UROWID:
5128 case VARRAY:
5129 case VARYING:
5130 case BFILE:
5131 case BLOB:
5132 case CLOB:
5133 case NCLOB:
5134 case YEAR:
5135 case LOCAL:
5136 case WITH:
5137 case ZONE:
5138 case CHARACTER:
5139 case AFTER:
5140 case BEFORE:
5141 case OLD:
5142 case PARENT:
5143 case ANALYZE:
5144 case ASSOCIATE:
5145 case AUDIT:
5146 case COMPOUND:
5147 case DATABASE:
5148 case CALL:
5149 case DDL:
5150 case DISASSOCIATE:
5151 case EACH:
5152 case FOLLOWS:
5153 case LOGOFF:
5154 case LOGON:
5155 case NESTED:
5156 case NOAUDIT:
5157 case SCHEMA:
5158 case SERVERERROR:
5159 case SHUTDOWN:
5160 case STARTUP:
5161 case STATEMENT:
5162 case STATISTICS:
5163 case SUSPEND:
5164 case TRUNCATE:
5165 case WRAPPED:
5166 case LIBRARY:
5167 case NAME:
5168 case STRUCT:
5169 case CONTEXT:
5170 case PARAMETERS:
5171 case LENGTH:
5172 case TDO:
5173 case MAXLEN:
5174 case CHARSETID:
5175 case CHARSETFORM:
5176 case ACCEPT:
5177 case ACCESSIBLE:
5178 case COPY:
5179 case DEFINE:
5180 case DISCONNECT:
5181 case HOST:
5182 case PRINT:
5183 case QUIT:
5184 case REMARK:
5185 case UNDEFINE:
5186 case VARIABLE:
5187 case WHENEVER:
5188 case ATTACH:
5189 case CAST:
5190 case TREAT:
5191 case TRIM:
5192 case LEFT:
5193 case RIGHT:
5194 case BOTH:
5195 case EMPTY:
5196 case MULTISET:
5197 case SUBMULTISET:
5198 case LEADING:
5199 case TRAILING:
5200 case CHAR_CS:
5201 case NCHAR_CS:
5202 case DBTIMEZONE:
5203 case SESSIONTIMEZONE:
5204 case AUTHENTICATED:
5205 case LINK:
5206 case SHARED:
5207 case DIRECTORY:
5208 case USER:
5209 case IDENTIFIER:
5210 case QUOTED_LITERAL:
5211 case SQLDATA_CLASS:
5212 case CUSTOMDATUM_CLASS:
5213 case ORADATA_CLASS:
5214 case JAVA_INTERFACE_CLASS:
5215 ID();
5216 break;
5217 default:
5218 jj_la1[53] = jj_gen;
5219 ;
5220 }
5221 jj_consume_token(BY);
5222 jj_consume_token(5);
5223 ID();
5224 label_14:
5225 while (true) {
5226 switch (jj_nt.kind) {
5227 case 6:
5228 ;
5229 break;
5230 default:
5231 jj_la1[54] = jj_gen;
5232 break label_14;
5233 }
5234 jj_consume_token(6);
5235 ID();
5236 }
5237 jj_consume_token(7);
5238 break;
5239 default:
5240 jj_la1[55] = jj_gen;
5241 jj_consume_token(-1);
5242 throw new ParseException();
5243 }
5244 break;
5245 default:
5246 jj_la1[56] = jj_gen;
5247 ;
5248 }
5249 break;
5250 case RESULT_CACHE:
5251 jj_consume_token(RESULT_CACHE);
5252 switch (jj_nt.kind) {
5253 case RELIES_ON:
5254 jj_consume_token(RELIES_ON);
5255 jj_consume_token(5);
5256 ID();
5257 switch (jj_nt.kind) {
5258 case 3:
5259 jj_consume_token(3);
5260 ID();
5261 break;
5262 default:
5263 jj_la1[57] = jj_gen;
5264 ;
5265 }
5266 label_15:
5267 while (true) {
5268 switch (jj_nt.kind) {
5269 case 6:
5270 ;
5271 break;
5272 default:
5273 jj_la1[58] = jj_gen;
5274 break label_15;
5275 }
5276 jj_consume_token(6);
5277 ID();
5278 switch (jj_nt.kind) {
5279 case 3:
5280 jj_consume_token(3);
5281 ID();
5282 break;
5283 default:
5284 jj_la1[59] = jj_gen;
5285 ;
5286 }
5287 }
5288 jj_consume_token(7);
5289 break;
5290 default:
5291 jj_la1[60] = jj_gen;
5292 ;
5293 }
5294 break;
5295 default:
5296 jj_la1[61] = jj_gen;
5297 jj_consume_token(-1);
5298 throw new ParseException();
5299 }
5300 }
5301 switch (jj_nt.kind) {
5302 case AGGREGATE:
5303 jj_consume_token(AGGREGATE);
5304 jj_consume_token(USING);
5305 ID();
5306 break;
5307 default:
5308 jj_la1[62] = jj_gen;
5309 ;
5310 }
5311 switch (jj_nt.kind) {
5312 case AS:
5313 case IS:
5314 switch (jj_nt.kind) {
5315 case IS:
5316 jj_consume_token(IS);
5317 break;
5318 case AS:
5319 jj_consume_token(AS);
5320 break;
5321 default:
5322 jj_la1[63] = jj_gen;
5323 jj_consume_token(-1);
5324 throw new ParseException();
5325 }
5326 if (jj_2_21(2)) {
5327 CallSpecTail();
5328 } else {
5329 switch (jj_nt.kind) {
5330 case REPLACE:
5331 case DEFINER:
5332 case CURRENT_USER:
5333 case SERIALLY_REUSABLE:
5334 case RESTRICT_REFERENCES:
5335 case EXCEPTION_INIT:
5336 case AUTONOMOUS_TRANSACTION:
5337 case LANGUAGE:
5338 case INLINE:
5339 case ADD:
5340 case AGGREGATE:
5341 case ALL:
5342 case ALTER:
5343 case AND:
5344 case ANY:
5345 case ARRAY:
5346 case AS:
5347 case ASC:
5348 case AT:
5349 case ATTRIBUTE:
5350 case AUTHID:
5351 case AVG:
5352 case BEGIN:
5353 case BETWEEN:
5354 case BINARY_INTEGER:
5355 case BODY:
5356 case BOOLEAN:
5357 case BULK:
5358 case BY:
5359 case BYTE:
5360 case CASCADE:
5361 case CASE:
5362 case CHAR:
5363 case CHAR_BASE:
5364 case CHECK:
5365 case CLOSE:
5366 case CLUSTER:
5367 case COALESCE:
5368 case COLLECT:
5369 case COLUMN:
5370 case COMMENT:
5371 case COMMIT:
5372 case COMPRESS:
5373 case CONNECT:
5374 case CONSTANT:
5375 case CONSTRUCTOR:
5376 case CONTINUE:
5377 case CONVERT:
5378 case CREATE:
5379 case CURRENT:
5380 case CURRVAL:
5381 case CURSOR:
5382 case DATA:
5383 case DATE:
5384 case DAY:
5385 case DECLARE:
5386 case DECIMAL:
5387 case _DEFAULT:
5388 case DELETE:
5389 case DESC:
5390 case DISABLE:
5391 case DISTINCT:
5392 case DO:
5393 case DROP:
5394 case EDITIONABLE:
5395 case ELEMENT:
5396 case ELSE:
5397 case ELSIF:
5398 case ENABLE:
5399 case ESCAPE:
5400 case EXCEPT:
5401 case EXCEPTION:
5402 case EXCEPTIONS:
5403 case EXCLUSIVE:
5404 case EXECUTE:
5405 case EXISTS:
5406 case EXIT:
5407 case EXTERNAL:
5408 case EXTENDS:
5409 case EXTRACT:
5410 case FALSE:
5411 case FETCH:
5412 case FINAL:
5413 case FLOAT:
5414 case FOR:
5415 case FORALL:
5416 case FORCE:
5417 case FROM:
5418 case FUNCTION:
5419 case GLOBAL:
5420 case GOTO:
5421 case GROUP:
5422 case HASH:
5423 case HAVING:
5424 case HEAP:
5425 case HOUR:
5426 case IF:
5427 case IMMEDIATE:
5428 case IN:
5429 case INDEX:
5430 case INDICES:
5431 case INDEXTYPE:
5432 case INDICATOR:
5433 case INSERT:
5434 case INSTANTIABLE:
5435 case INTEGER:
5436 case INTERFACE:
5437 case INTERSECT:
5438 case INTERVAL:
5439 case INTO:
5440 case INVALIDATE:
5441 case IS:
5442 case ISOLATION:
5443 case JAVA:
5444 case LEVEL:
5445 case LIKE:
5446 case LIMIT:
5447 case LIMITED:
5448 case LOCK:
5449 case LONG:
5450 case LOOP:
5451 case MAP:
5452 case MAX:
5453 case MEMBER:
5454 case MERGE:
5455 case MIN:
5456 case MINUS:
5457 case MINUTE:
5458 case MLSLABEL:
5459 case MODIFY:
5460 case MOD:
5461 case MODE:
5462 case MONTH:
5463 case NATURAL:
5464 case NATURALN:
5465 case NEW:
5466 case NEXTVAL:
5467 case NO:
5468 case NOCOPY:
5469 case NONEDITIONABLE:
5470 case NOT:
5471 case NOWAIT:
5472 case NULL:
5473 case NULLIF:
5474 case NUMBER:
5475 case BFILE_BASE:
5476 case BLOB_BASE:
5477 case CLOB_BASE:
5478 case DATE_BASE:
5479 case NUMBER_BASE:
5480 case OBJECT:
5481 case OCIROWID:
5482 case OF:
5483 case OID:
5484 case ON:
5485 case OPAQUE:
5486 case OPEN:
5487 case OPERATOR:
5488 case OPTION:
5489 case OR:
5490 case ORDER:
5491 case ORGANIZATION:
5492 case OTHERS:
5493 case OUT:
5494 case OVERRIDING:
5495 case PACKAGE:
5496 case PARTITION:
5497 case PCTFREE:
5498 case PLS_INTEGER:
5499 case POSITIVE:
5500 case POSITIVEN:
5501 case PRAGMA:
5502 case PRESERVE:
5503 case PRIOR:
5504 case PROMPT:
5505 case PRIVATE:
5506 case PROCEDURE:
5507 case PUBLIC:
5508 case RAISE:
5509 case RANGE:
5510 case RAW:
5511 case REAL:
5512 case RECORD:
5513 case REF:
5514 case RELEASE:
5515 case RELIES_ON:
5516 case RENAME:
5517 case RESULT:
5518 case RETURN:
5519 case RETURNING:
5520 case REVERSE:
5521 case ROLLBACK:
5522 case ROW:
5523 case ROWS:
5524 case ROWID:
5525 case ROWNUM:
5526 case ROWTYPE:
5527 case SAVE:
5528 case SAVEPOINT:
5529 case SECOND:
5530 case SELECT:
5531 case SELF:
5532 case SEPARATE:
5533 case SET:
5534 case SHARE:
5535 case SMALLINT:
5536 case SPACE:
5537 case SQL:
5538 case SQLCODE:
5539 case SQLERRM:
5540 case START:
5541 case STATIC:
5542 case STDDEV:
5543 case SUBTYPE:
5544 case SUBSTITUTABLE:
5545 case SUCCESSFUL:
5546 case SUM:
5547 case SYNONYM:
5548 case SYSDATE:
5549 case SYS_REFCURSOR:
5550 case TABLE:
5551 case TEMPORARY:
5552 case THEN:
5553 case TIME:
5554 case TIMESTAMP:
5555 case TIMEZONE_REGION:
5556 case TIMEZONE_ABBR:
5557 case TIMEZONE_MINUTE:
5558 case TIMEZONE_HOUR:
5559 case TO:
5560 case TRANSACTION:
5561 case TRIGGER:
5562 case TRUE:
5563 case TYPE:
5564 case UI:
5565 case UNDER:
5566 case USING:
5567 case WHILE:
5568 case YES:
5569 case SHOW:
5570 case A:
5571 case UPDATE:
5572 case VARCHAR:
5573 case VARCHAR2:
5574 case DOUBLE:
5575 case DEC:
5576 case PRECISION:
5577 case INT:
5578 case NUMERIC:
5579 case SIGNTYPE:
5580 case NCHAR:
5581 case NVARCHAR2:
5582 case STRING:
5583 case UROWID:
5584 case VARRAY:
5585 case VARYING:
5586 case BFILE:
5587 case BLOB:
5588 case CLOB:
5589 case NCLOB:
5590 case YEAR:
5591 case LOCAL:
5592 case WITH:
5593 case ZONE:
5594 case CHARACTER:
5595 case AFTER:
5596 case BEFORE:
5597 case OLD:
5598 case PARENT:
5599 case CC_IF:
5600 case ANALYZE:
5601 case ASSOCIATE:
5602 case AUDIT:
5603 case COMPOUND:
5604 case DATABASE:
5605 case CALL:
5606 case DDL:
5607 case DISASSOCIATE:
5608 case EACH:
5609 case FOLLOWS:
5610 case LOGOFF:
5611 case LOGON:
5612 case NESTED:
5613 case NOAUDIT:
5614 case SCHEMA:
5615 case SERVERERROR:
5616 case SHUTDOWN:
5617 case STARTUP:
5618 case STATEMENT:
5619 case STATISTICS:
5620 case SUSPEND:
5621 case TRUNCATE:
5622 case WRAPPED:
5623 case LIBRARY:
5624 case NAME:
5625 case STRUCT:
5626 case CONTEXT:
5627 case PARAMETERS:
5628 case LENGTH:
5629 case TDO:
5630 case MAXLEN:
5631 case CHARSETID:
5632 case CHARSETFORM:
5633 case ACCEPT:
5634 case ACCESSIBLE:
5635 case COPY:
5636 case DEFINE:
5637 case DISCONNECT:
5638 case HOST:
5639 case PRINT:
5640 case QUIT:
5641 case REMARK:
5642 case UNDEFINE:
5643 case VARIABLE:
5644 case WHENEVER:
5645 case ATTACH:
5646 case CAST:
5647 case TREAT:
5648 case TRIM:
5649 case LEFT:
5650 case RIGHT:
5651 case BOTH:
5652 case EMPTY:
5653 case MULTISET:
5654 case SUBMULTISET:
5655 case LEADING:
5656 case TRAILING:
5657 case CHAR_CS:
5658 case NCHAR_CS:
5659 case DBTIMEZONE:
5660 case SESSIONTIMEZONE:
5661 case AUTHENTICATED:
5662 case LINK:
5663 case SHARED:
5664 case DIRECTORY:
5665 case USER:
5666 case IDENTIFIER:
5667 case QUOTED_LITERAL:
5668 case SQLDATA_CLASS:
5669 case CUSTOMDATUM_CLASS:
5670 case ORADATA_CLASS:
5671 case JAVA_INTERFACE_CLASS:
5672 DeclarativeSection();
5673 jj_consume_token(BEGIN);
5674 switch (jj_nt.kind) {
5675 case PRAGMA:
5676 Pragma();
5677 break;
5678 default:
5679 jj_la1[64] = jj_gen;
5680 ;
5681 }
5682 label_16:
5683 while (true) {
5684 switch (jj_nt.kind) {
5685 case 5:
5686 case 16:
5687 case 17:
5688 case 21:
5689 case REPLACE:
5690 case DEFINER:
5691 case CURRENT_USER:
5692 case LANGUAGE:
5693 case INLINE:
5694 case ADD:
5695 case AGGREGATE:
5696 case ARRAY:
5697 case AT:
5698 case ATTRIBUTE:
5699 case AUTHID:
5700 case BEGIN:
5701 case BODY:
5702 case BULK:
5703 case BYTE:
5704 case CASCADE:
5705 case CASE:
5706 case CLOSE:
5707 case COALESCE:
5708 case COLLECT:
5709 case COLUMN:
5710 case COMMENT:
5711 case COMMIT:
5712 case CONSTRUCTOR:
5713 case CONTINUE:
5714 case CONVERT:
5715 case CURRENT:
5716 case CURSOR:
5717 case DATA:
5718 case DATE:
5719 case DAY:
5720 case DECLARE:
5721 case DELETE:
5722 case DISABLE:
5723 case EDITIONABLE:
5724 case ELEMENT:
5725 case ENABLE:
5726 case ESCAPE:
5727 case EXCEPT:
5728 case EXCEPTIONS:
5729 case EXECUTE:
5730 case EXIT:
5731 case EXTERNAL:
5732 case EXTENDS:
5733 case EXTRACT:
5734 case FALSE:
5735 case FETCH:
5736 case FINAL:
5737 case FOR:
5738 case FORALL:
5739 case FORCE:
5740 case FUNCTION:
5741 case GLOBAL:
5742 case GOTO:
5743 case HASH:
5744 case HEAP:
5745 case HOUR:
5746 case IF:
5747 case IMMEDIATE:
5748 case INDICES:
5749 case INDEXTYPE:
5750 case INDICATOR:
5751 case INSERT:
5752 case INSTANTIABLE:
5753 case INTERVAL:
5754 case INVALIDATE:
5755 case ISOLATION:
5756 case JAVA:
5757 case LEVEL:
5758 case LIMIT:
5759 case LOCK:
5760 case LOOP:
5761 case MAP:
5762 case MAX:
5763 case MEMBER:
5764 case MERGE:
5765 case MIN:
5766 case MINUTE:
5767 case MLSLABEL:
5768 case MODIFY:
5769 case MOD:
5770 case MONTH:
5771 case NATURAL:
5772 case NEW:
5773 case NEW_DOT:
5774 case NO:
5775 case NONEDITIONABLE:
5776 case NOT:
5777 case NULL:
5778 case NULLIF:
5779 case OBJECT:
5780 case OID:
5781 case OPAQUE:
5782 case OPEN:
5783 case OPERATOR:
5784 case ORGANIZATION:
5785 case OTHERS:
5786 case OVERRIDING:
5787 case PACKAGE:
5788 case PARTITION:
5789 case PIPE:
5790 case PRAGMA:
5791 case PRESERVE:
5792 case PRIVATE:
5793 case PROCEDURE:
5794 case RAISE:
5795 case RANGE:
5796 case RAW:
5797 case REAL:
5798 case RECORD:
5799 case REF:
5800 case RELEASE:
5801 case RELIES_ON:
5802 case RENAME:
5803 case RESULT:
5804 case RETURN:
5805 case RETURNING:
5806 case REVERSE:
5807 case ROLLBACK:
5808 case ROW:
5809 case ROWS:
5810 case ROWID:
5811 case ROWNUM:
5812 case SAVE:
5813 case SAVEPOINT:
5814 case SECOND:
5815 case SELECT:
5816 case SELF:
5817 case SET:
5818 case SPACE:
5819 case SQL:
5820 case SQLCODE:
5821 case SQLERRM:
5822 case STATIC:
5823 case SUBTYPE:
5824 case SUBSTITUTABLE:
5825 case SUCCESSFUL:
5826 case SYSDATE:
5827 case SYS_REFCURSOR:
5828 case TEMPORARY:
5829 case TIME:
5830 case TIMESTAMP:
5831 case TIMEZONE_REGION:
5832 case TIMEZONE_ABBR:
5833 case TIMEZONE_MINUTE:
5834 case TIMEZONE_HOUR:
5835 case TRANSACTION:
5836 case TRUE:
5837 case TYPE:
5838 case UNDER:
5839 case USING:
5840 case WHILE:
5841 case YES:
5842 case SHOW:
5843 case A:
5844 case UPDATE:
5845 case DOUBLE:
5846 case DEC:
5847 case PRECISION:
5848 case INT:
5849 case NUMERIC:
5850 case NCHAR:
5851 case NVARCHAR2:
5852 case STRING:
5853 case UROWID:
5854 case VARRAY:
5855 case VARYING:
5856 case BFILE:
5857 case BLOB:
5858 case CLOB:
5859 case NCLOB:
5860 case YEAR:
5861 case LOCAL:
5862 case WITH:
5863 case ZONE:
5864 case CHARACTER:
5865 case AFTER:
5866 case BEFORE:
5867 case OLD:
5868 case PARENT:
5869 case CC_IF:
5870 case CC_ERROR:
5871 case ANALYZE:
5872 case ASSOCIATE:
5873 case AUDIT:
5874 case COMPOUND:
5875 case DATABASE:
5876 case CALL:
5877 case DDL:
5878 case DISASSOCIATE:
5879 case EACH:
5880 case FOLLOWS:
5881 case LOGOFF:
5882 case LOGON:
5883 case NESTED:
5884 case NOAUDIT:
5885 case SCHEMA:
5886 case SERVERERROR:
5887 case SHUTDOWN:
5888 case STARTUP:
5889 case STATEMENT:
5890 case STATISTICS:
5891 case SUSPEND:
5892 case TRUNCATE:
5893 case WRAPPED:
5894 case LIBRARY:
5895 case NAME:
5896 case STRUCT:
5897 case CONTEXT:
5898 case PARAMETERS:
5899 case LENGTH:
5900 case TDO:
5901 case MAXLEN:
5902 case CHARSETID:
5903 case CHARSETFORM:
5904 case ACCEPT:
5905 case ACCESSIBLE:
5906 case COPY:
5907 case DEFINE:
5908 case DISCONNECT:
5909 case HOST:
5910 case PRINT:
5911 case QUIT:
5912 case REMARK:
5913 case UNDEFINE:
5914 case VARIABLE:
5915 case WHENEVER:
5916 case ATTACH:
5917 case CAST:
5918 case TREAT:
5919 case TRIM:
5920 case LEFT:
5921 case RIGHT:
5922 case BOTH:
5923 case EMPTY:
5924 case MULTISET:
5925 case SUBMULTISET:
5926 case LEADING:
5927 case TRAILING:
5928 case CHAR_CS:
5929 case NCHAR_CS:
5930 case DBTIMEZONE:
5931 case SESSIONTIMEZONE:
5932 case AUTHENTICATED:
5933 case LINK:
5934 case SHARED:
5935 case DIRECTORY:
5936 case USER:
5937 case IDENTIFIER:
5938 case UNSIGNED_NUMERIC_LITERAL:
5939 case CHARACTER_LITERAL:
5940 case STRING_LITERAL:
5941 case QUOTED_LITERAL:
5942 ;
5943 break;
5944 default:
5945 jj_la1[65] = jj_gen;
5946 break label_16;
5947 }
5948 Statement();
5949 }
5950 switch (jj_nt.kind) {
5951 case EXCEPTION:
5952 ExceptionHandler();
5953 break;
5954 default:
5955 jj_la1[66] = jj_gen;
5956 ;
5957 }
5958 jj_consume_token(END);
5959 switch (jj_nt.kind) {
5960 case REPLACE:
5961 case DEFINER:
5962 case CURRENT_USER:
5963 case SERIALLY_REUSABLE:
5964 case RESTRICT_REFERENCES:
5965 case EXCEPTION_INIT:
5966 case AUTONOMOUS_TRANSACTION:
5967 case LANGUAGE:
5968 case INLINE:
5969 case ADD:
5970 case AGGREGATE:
5971 case ALL:
5972 case ALTER:
5973 case AND:
5974 case ANY:
5975 case ARRAY:
5976 case AS:
5977 case ASC:
5978 case AT:
5979 case ATTRIBUTE:
5980 case AUTHID:
5981 case AVG:
5982 case BETWEEN:
5983 case BINARY_INTEGER:
5984 case BODY:
5985 case BOOLEAN:
5986 case BULK:
5987 case BY:
5988 case BYTE:
5989 case CASCADE:
5990 case CASE:
5991 case CHAR:
5992 case CHAR_BASE:
5993 case CHECK:
5994 case CLOSE:
5995 case CLUSTER:
5996 case COALESCE:
5997 case COLLECT:
5998 case COLUMN:
5999 case COMMENT:
6000 case COMMIT:
6001 case COMPRESS:
6002 case CONNECT:
6003 case CONSTANT:
6004 case CONSTRUCTOR:
6005 case CONTINUE:
6006 case CONVERT:
6007 case CREATE:
6008 case CURRENT:
6009 case CURRVAL:
6010 case CURSOR:
6011 case DATA:
6012 case DATE:
6013 case DAY:
6014 case DECLARE:
6015 case DECIMAL:
6016 case _DEFAULT:
6017 case DELETE:
6018 case DESC:
6019 case DISABLE:
6020 case DISTINCT:
6021 case DO:
6022 case DROP:
6023 case EDITIONABLE:
6024 case ELEMENT:
6025 case ELSE:
6026 case ELSIF:
6027 case ENABLE:
6028 case ESCAPE:
6029 case EXCEPT:
6030 case EXCEPTION:
6031 case EXCEPTIONS:
6032 case EXCLUSIVE:
6033 case EXECUTE:
6034 case EXISTS:
6035 case EXIT:
6036 case EXTERNAL:
6037 case EXTENDS:
6038 case EXTRACT:
6039 case FALSE:
6040 case FETCH:
6041 case FINAL:
6042 case FLOAT:
6043 case FOR:
6044 case FORALL:
6045 case FORCE:
6046 case FROM:
6047 case FUNCTION:
6048 case GLOBAL:
6049 case GOTO:
6050 case GROUP:
6051 case HASH:
6052 case HAVING:
6053 case HEAP:
6054 case HOUR:
6055 case IF:
6056 case IMMEDIATE:
6057 case IN:
6058 case INDEX:
6059 case INDICES:
6060 case INDEXTYPE:
6061 case INDICATOR:
6062 case INSERT:
6063 case INSTANTIABLE:
6064 case INTEGER:
6065 case INTERFACE:
6066 case INTERSECT:
6067 case INTERVAL:
6068 case INTO:
6069 case INVALIDATE:
6070 case IS:
6071 case ISOLATION:
6072 case JAVA:
6073 case LEVEL:
6074 case LIKE:
6075 case LIMIT:
6076 case LIMITED:
6077 case LOCK:
6078 case LONG:
6079 case LOOP:
6080 case MAP:
6081 case MAX:
6082 case MEMBER:
6083 case MERGE:
6084 case MIN:
6085 case MINUS:
6086 case MINUTE:
6087 case MLSLABEL:
6088 case MODIFY:
6089 case MOD:
6090 case MODE:
6091 case MONTH:
6092 case NATURAL:
6093 case NATURALN:
6094 case NEW:
6095 case NEXTVAL:
6096 case NO:
6097 case NOCOPY:
6098 case NONEDITIONABLE:
6099 case NOT:
6100 case NOWAIT:
6101 case NULL:
6102 case NULLIF:
6103 case NUMBER:
6104 case BFILE_BASE:
6105 case BLOB_BASE:
6106 case CLOB_BASE:
6107 case DATE_BASE:
6108 case NUMBER_BASE:
6109 case OBJECT:
6110 case OCIROWID:
6111 case OF:
6112 case OID:
6113 case ON:
6114 case OPAQUE:
6115 case OPEN:
6116 case OPERATOR:
6117 case OPTION:
6118 case OR:
6119 case ORDER:
6120 case ORGANIZATION:
6121 case OTHERS:
6122 case OUT:
6123 case OVERRIDING:
6124 case PACKAGE:
6125 case PARTITION:
6126 case PCTFREE:
6127 case PLS_INTEGER:
6128 case POSITIVE:
6129 case POSITIVEN:
6130 case PRESERVE:
6131 case PRIOR:
6132 case PROMPT:
6133 case PRIVATE:
6134 case PROCEDURE:
6135 case PUBLIC:
6136 case RAISE:
6137 case RANGE:
6138 case RAW:
6139 case REAL:
6140 case RECORD:
6141 case REF:
6142 case RELEASE:
6143 case RELIES_ON:
6144 case RENAME:
6145 case RESULT:
6146 case RETURN:
6147 case RETURNING:
6148 case REVERSE:
6149 case ROLLBACK:
6150 case ROW:
6151 case ROWS:
6152 case ROWID:
6153 case ROWNUM:
6154 case ROWTYPE:
6155 case SAVE:
6156 case SAVEPOINT:
6157 case SECOND:
6158 case SELECT:
6159 case SELF:
6160 case SEPARATE:
6161 case SET:
6162 case SHARE:
6163 case SMALLINT:
6164 case SPACE:
6165 case SQL:
6166 case SQLCODE:
6167 case SQLERRM:
6168 case START:
6169 case STATIC:
6170 case STDDEV:
6171 case SUBTYPE:
6172 case SUBSTITUTABLE:
6173 case SUCCESSFUL:
6174 case SUM:
6175 case SYNONYM:
6176 case SYSDATE:
6177 case SYS_REFCURSOR:
6178 case TABLE:
6179 case TEMPORARY:
6180 case THEN:
6181 case TIME:
6182 case TIMESTAMP:
6183 case TIMEZONE_REGION:
6184 case TIMEZONE_ABBR:
6185 case TIMEZONE_MINUTE:
6186 case TIMEZONE_HOUR:
6187 case TO:
6188 case TRANSACTION:
6189 case TRIGGER:
6190 case TRUE:
6191 case TYPE:
6192 case UI:
6193 case UNDER:
6194 case USING:
6195 case WHILE:
6196 case YES:
6197 case SHOW:
6198 case A:
6199 case UPDATE:
6200 case VARCHAR:
6201 case VARCHAR2:
6202 case DOUBLE:
6203 case DEC:
6204 case PRECISION:
6205 case INT:
6206 case NUMERIC:
6207 case SIGNTYPE:
6208 case NCHAR:
6209 case NVARCHAR2:
6210 case STRING:
6211 case UROWID:
6212 case VARRAY:
6213 case VARYING:
6214 case BFILE:
6215 case BLOB:
6216 case CLOB:
6217 case NCLOB:
6218 case YEAR:
6219 case LOCAL:
6220 case WITH:
6221 case ZONE:
6222 case CHARACTER:
6223 case AFTER:
6224 case BEFORE:
6225 case OLD:
6226 case PARENT:
6227 case ANALYZE:
6228 case ASSOCIATE:
6229 case AUDIT:
6230 case COMPOUND:
6231 case DATABASE:
6232 case CALL:
6233 case DDL:
6234 case DISASSOCIATE:
6235 case EACH:
6236 case FOLLOWS:
6237 case LOGOFF:
6238 case LOGON:
6239 case NESTED:
6240 case NOAUDIT:
6241 case SCHEMA:
6242 case SERVERERROR:
6243 case SHUTDOWN:
6244 case STARTUP:
6245 case STATEMENT:
6246 case STATISTICS:
6247 case SUSPEND:
6248 case TRUNCATE:
6249 case WRAPPED:
6250 case LIBRARY:
6251 case NAME:
6252 case STRUCT:
6253 case CONTEXT:
6254 case PARAMETERS:
6255 case LENGTH:
6256 case TDO:
6257 case MAXLEN:
6258 case CHARSETID:
6259 case CHARSETFORM:
6260 case ACCEPT:
6261 case ACCESSIBLE:
6262 case COPY:
6263 case DEFINE:
6264 case DISCONNECT:
6265 case HOST:
6266 case PRINT:
6267 case QUIT:
6268 case REMARK:
6269 case UNDEFINE:
6270 case VARIABLE:
6271 case WHENEVER:
6272 case ATTACH:
6273 case CAST:
6274 case TREAT:
6275 case TRIM:
6276 case LEFT:
6277 case RIGHT:
6278 case BOTH:
6279 case EMPTY:
6280 case MULTISET:
6281 case SUBMULTISET:
6282 case LEADING:
6283 case TRAILING:
6284 case CHAR_CS:
6285 case NCHAR_CS:
6286 case DBTIMEZONE:
6287 case SESSIONTIMEZONE:
6288 case AUTHENTICATED:
6289 case LINK:
6290 case SHARED:
6291 case DIRECTORY:
6292 case USER:
6293 case IDENTIFIER:
6294 case QUOTED_LITERAL:
6295 case SQLDATA_CLASS:
6296 case CUSTOMDATUM_CLASS:
6297 case ORADATA_CLASS:
6298 case JAVA_INTERFACE_CLASS:
6299 ID();
6300 break;
6301 default:
6302 jj_la1[67] = jj_gen;
6303 ;
6304 }
6305 break;
6306 default:
6307 jj_la1[68] = jj_gen;
6308 jj_consume_token(-1);
6309 throw new ParseException();
6310 }
6311 }
6312 break;
6313 default:
6314 jj_la1[69] = jj_gen;
6315 ;
6316 }
6317 jj_consume_token(4);
6318 break;
6319 default:
6320 jj_la1[70] = jj_gen;
6321 jj_consume_token(-1);
6322 throw new ParseException();
6323 }
6324 jjtree.closeNodeScope(jjtn000, true);
6325 jjtc000 = false;
6326 {if (true) return jjtn000 ;}
6327 } catch (Throwable jjte000) {
6328 if (jjtc000) {
6329 jjtree.clearNodeScope(jjtn000);
6330 jjtc000 = false;
6331 } else {
6332 jjtree.popNode();
6333 }
6334 if (jjte000 instanceof RuntimeException) {
6335 {if (true) throw (RuntimeException)jjte000;}
6336 }
6337 if (jjte000 instanceof ParseException) {
6338 {if (true) throw (ParseException)jjte000;}
6339 }
6340 {if (true) throw (Error)jjte000;}
6341 } finally {
6342 if (jjtc000) {
6343 jjtree.closeNodeScope(jjtn000, true);
6344 }
6345 }
6346 throw new Error("Missing return statement in function");
6347 }
6348
6349 final public ASTObjectNameDeclaration ObjectNameDeclaration() throws ParseException {
6350
6351 ASTObjectNameDeclaration jjtn000 = new ASTObjectNameDeclaration(this, JJTOBJECTNAMEDECLARATION);
6352 boolean jjtc000 = true;
6353 jjtree.openNodeScope(jjtn000);PLSQLNode schemaName = null, objectName = null ;
6354 try {
6355 if (jj_2_22(2)) {
6356 schemaName = ID();
6357 jj_consume_token(3);
6358 } else {
6359 ;
6360 }
6361 objectName = ID();
6362 jjtn000.setImage( (null == schemaName) ? objectName.getImage() : (schemaName.getImage() + "." + objectName.getImage() ) ) ;
6363 jjtree.closeNodeScope(jjtn000, true);
6364 jjtc000 = false;
6365 {if (true) return jjtn000 ;}
6366 } catch (Throwable jjte000) {
6367 if (jjtc000) {
6368 jjtree.clearNodeScope(jjtn000);
6369 jjtc000 = false;
6370 } else {
6371 jjtree.popNode();
6372 }
6373 if (jjte000 instanceof RuntimeException) {
6374 {if (true) throw (RuntimeException)jjte000;}
6375 }
6376 if (jjte000 instanceof ParseException) {
6377 {if (true) throw (ParseException)jjte000;}
6378 }
6379 {if (true) throw (Error)jjte000;}
6380 } finally {
6381 if (jjtc000) {
6382 jjtree.closeNodeScope(jjtn000, true);
6383 }
6384 }
6385 throw new Error("Missing return statement in function");
6386 }
6387
6388 final public ASTFormalParameter FormalParameter() throws ParseException {
6389
6390 ASTFormalParameter jjtn000 = new ASTFormalParameter(this, JJTFORMALPARAMETER);
6391 boolean jjtc000 = true;
6392 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6393 try {
6394 simpleNode = ID();
6395 if (jj_2_25(2)) {
6396 if (jj_2_24(2)) {
6397 switch (jj_nt.kind) {
6398 case OUT:
6399 jj_consume_token(OUT);
6400 break;
6401 case IN:
6402 jj_consume_token(IN);
6403 jj_consume_token(OUT);
6404 break;
6405 default:
6406 jj_la1[71] = jj_gen;
6407 jj_consume_token(-1);
6408 throw new ParseException();
6409 }
6410 if (jj_2_23(2)) {
6411 jj_consume_token(NOCOPY);
6412 } else {
6413 ;
6414 }
6415 } else {
6416 switch (jj_nt.kind) {
6417 case IN:
6418 jj_consume_token(IN);
6419 break;
6420 default:
6421 jj_la1[72] = jj_gen;
6422 jj_consume_token(-1);
6423 throw new ParseException();
6424 }
6425 }
6426 } else {
6427 ;
6428 }
6429 switch (jj_nt.kind) {
6430 case 8:
6431 jj_consume_token(8);
6432 break;
6433 case REPLACE:
6434 case DEFINER:
6435 case CURRENT_USER:
6436 case LANGUAGE:
6437 case INLINE:
6438 case ADD:
6439 case AGGREGATE:
6440 case ARRAY:
6441 case AT:
6442 case ATTRIBUTE:
6443 case AUTHID:
6444 case BINARY_INTEGER:
6445 case BODY:
6446 case BOOLEAN:
6447 case BULK:
6448 case BYTE:
6449 case CASCADE:
6450 case CHAR:
6451 case CHAR_BASE:
6452 case CLOSE:
6453 case COALESCE:
6454 case COLLECT:
6455 case COLUMN:
6456 case COMMENT:
6457 case COMMIT:
6458 case CONSTRUCTOR:
6459 case CONTINUE:
6460 case CONVERT:
6461 case CURRENT:
6462 case CURSOR:
6463 case DATA:
6464 case DATE:
6465 case DAY:
6466 case DECIMAL:
6467 case DISABLE:
6468 case EDITIONABLE:
6469 case ELEMENT:
6470 case ENABLE:
6471 case ESCAPE:
6472 case EXCEPT:
6473 case EXCEPTIONS:
6474 case EXIT:
6475 case EXTERNAL:
6476 case EXTENDS:
6477 case EXTRACT:
6478 case FALSE:
6479 case FINAL:
6480 case FLOAT:
6481 case FORCE:
6482 case FUNCTION:
6483 case GLOBAL:
6484 case HASH:
6485 case HEAP:
6486 case HOUR:
6487 case IMMEDIATE:
6488 case INDICES:
6489 case INDEXTYPE:
6490 case INDICATOR:
6491 case INSTANTIABLE:
6492 case INTEGER:
6493 case INTERVAL:
6494 case INVALIDATE:
6495 case ISOLATION:
6496 case JAVA:
6497 case LEVEL:
6498 case LIMIT:
6499 case LONG:
6500 case LOOP:
6501 case MAP:
6502 case MAX:
6503 case MEMBER:
6504 case MERGE:
6505 case MIN:
6506 case MINUTE:
6507 case MLSLABEL:
6508 case MODIFY:
6509 case MOD:
6510 case MONTH:
6511 case NATURAL:
6512 case NATURALN:
6513 case NEW:
6514 case NO:
6515 case NONEDITIONABLE:
6516 case NULLIF:
6517 case NUMBER:
6518 case BFILE_BASE:
6519 case BLOB_BASE:
6520 case CLOB_BASE:
6521 case DATE_BASE:
6522 case NUMBER_BASE:
6523 case OBJECT:
6524 case OID:
6525 case OPAQUE:
6526 case OPEN:
6527 case OPERATOR:
6528 case ORGANIZATION:
6529 case OTHERS:
6530 case OVERRIDING:
6531 case PACKAGE:
6532 case PARTITION:
6533 case PLS_INTEGER:
6534 case POSITIVE:
6535 case POSITIVEN:
6536 case PRESERVE:
6537 case PRIVATE:
6538 case PROCEDURE:
6539 case RANGE:
6540 case RAW:
6541 case REAL:
6542 case RECORD:
6543 case REF:
6544 case RELEASE:
6545 case RELIES_ON:
6546 case RENAME:
6547 case RESULT:
6548 case RETURN:
6549 case RETURNING:
6550 case REVERSE:
6551 case ROLLBACK:
6552 case ROW:
6553 case ROWS:
6554 case ROWID:
6555 case ROWNUM:
6556 case SAVE:
6557 case SAVEPOINT:
6558 case SECOND:
6559 case SELF:
6560 case SET:
6561 case SMALLINT:
6562 case SPACE:
6563 case SQL:
6564 case SQLCODE:
6565 case SQLERRM:
6566 case STATIC:
6567 case SUBTYPE:
6568 case SUBSTITUTABLE:
6569 case SUCCESSFUL:
6570 case SYSDATE:
6571 case SYS_REFCURSOR:
6572 case TEMPORARY:
6573 case TIME:
6574 case TIMESTAMP:
6575 case TIMEZONE_REGION:
6576 case TIMEZONE_ABBR:
6577 case TIMEZONE_MINUTE:
6578 case TIMEZONE_HOUR:
6579 case TRANSACTION:
6580 case TRUE:
6581 case TYPE:
6582 case UNDER:
6583 case USING:
6584 case YES:
6585 case SHOW:
6586 case A:
6587 case VARCHAR:
6588 case VARCHAR2:
6589 case DOUBLE:
6590 case DEC:
6591 case PRECISION:
6592 case INT:
6593 case NUMERIC:
6594 case SIGNTYPE:
6595 case NCHAR:
6596 case NVARCHAR2:
6597 case STRING:
6598 case UROWID:
6599 case VARRAY:
6600 case VARYING:
6601 case BFILE:
6602 case BLOB:
6603 case CLOB:
6604 case NCLOB:
6605 case YEAR:
6606 case LOCAL:
6607 case ZONE:
6608 case CHARACTER:
6609 case AFTER:
6610 case BEFORE:
6611 case OLD:
6612 case PARENT:
6613 case CC_IF:
6614 case ANALYZE:
6615 case ASSOCIATE:
6616 case AUDIT:
6617 case COMPOUND:
6618 case DATABASE:
6619 case CALL:
6620 case DDL:
6621 case DISASSOCIATE:
6622 case EACH:
6623 case FOLLOWS:
6624 case LOGOFF:
6625 case LOGON:
6626 case NESTED:
6627 case NOAUDIT:
6628 case SCHEMA:
6629 case SERVERERROR:
6630 case SHUTDOWN:
6631 case STARTUP:
6632 case STATEMENT:
6633 case STATISTICS:
6634 case SUSPEND:
6635 case TRUNCATE:
6636 case WRAPPED:
6637 case LIBRARY:
6638 case NAME:
6639 case STRUCT:
6640 case CONTEXT:
6641 case PARAMETERS:
6642 case LENGTH:
6643 case TDO:
6644 case MAXLEN:
6645 case CHARSETID:
6646 case CHARSETFORM:
6647 case ACCEPT:
6648 case ACCESSIBLE:
6649 case COPY:
6650 case DEFINE:
6651 case DISCONNECT:
6652 case HOST:
6653 case PRINT:
6654 case QUIT:
6655 case REMARK:
6656 case UNDEFINE:
6657 case VARIABLE:
6658 case WHENEVER:
6659 case ATTACH:
6660 case CAST:
6661 case TREAT:
6662 case TRIM:
6663 case LEFT:
6664 case RIGHT:
6665 case BOTH:
6666 case EMPTY:
6667 case MULTISET:
6668 case SUBMULTISET:
6669 case LEADING:
6670 case TRAILING:
6671 case CHAR_CS:
6672 case NCHAR_CS:
6673 case DBTIMEZONE:
6674 case SESSIONTIMEZONE:
6675 case AUTHENTICATED:
6676 case LINK:
6677 case SHARED:
6678 case DIRECTORY:
6679 case USER:
6680 case IDENTIFIER:
6681 case QUOTED_LITERAL:
6682 Datatype();
6683 break;
6684 default:
6685 jj_la1[73] = jj_gen;
6686 jj_consume_token(-1);
6687 throw new ParseException();
6688 }
6689 switch (jj_nt.kind) {
6690 case 9:
6691 case _DEFAULT:
6692 switch (jj_nt.kind) {
6693 case 9:
6694 jj_consume_token(9);
6695 jj_consume_token(10);
6696 break;
6697 case _DEFAULT:
6698 jj_consume_token(_DEFAULT);
6699 break;
6700 default:
6701 jj_la1[74] = jj_gen;
6702 jj_consume_token(-1);
6703 throw new ParseException();
6704 }
6705 Expression();
6706 break;
6707 default:
6708 jj_la1[75] = jj_gen;
6709 ;
6710 }
6711 jjtree.closeNodeScope(jjtn000, true);
6712 jjtc000 = false;
6713 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
6714 } catch (Throwable jjte000) {
6715 if (jjtc000) {
6716 jjtree.clearNodeScope(jjtn000);
6717 jjtc000 = false;
6718 } else {
6719 jjtree.popNode();
6720 }
6721 if (jjte000 instanceof RuntimeException) {
6722 {if (true) throw (RuntimeException)jjte000;}
6723 }
6724 if (jjte000 instanceof ParseException) {
6725 {if (true) throw (ParseException)jjte000;}
6726 }
6727 {if (true) throw (Error)jjte000;}
6728 } finally {
6729 if (jjtc000) {
6730 jjtree.closeNodeScope(jjtn000, true);
6731 }
6732 }
6733 throw new Error("Missing return statement in function");
6734 }
6735
6736 final public ASTMethodDeclaration MethodDeclaration() throws ParseException {
6737
6738 ASTMethodDeclaration jjtn000 = new ASTMethodDeclaration(this, JJTMETHODDECLARATION);
6739 boolean jjtc000 = true;
6740 jjtree.openNodeScope(jjtn000);
6741 try {
6742 switch (jj_nt.kind) {
6743 case CREATE:
6744 case FUNCTION:
6745 case PROCEDURE:
6746 ProgramUnit();
6747 break;
6748 case CONSTRUCTOR:
6749 case FINAL:
6750 case INSTANTIABLE:
6751 case MAP:
6752 case MEMBER:
6753 case NOT:
6754 case ORDER:
6755 case OVERRIDING:
6756 case STATIC:
6757 TypeMethod();
6758 break;
6759 default:
6760 jj_la1[76] = jj_gen;
6761 jj_consume_token(-1);
6762 throw new ParseException();
6763 }
6764 jjtree.closeNodeScope(jjtn000, true);
6765 jjtc000 = false;
6766 {if (true) return jjtn000 ;}
6767 } catch (Throwable jjte000) {
6768 if (jjtc000) {
6769 jjtree.clearNodeScope(jjtn000);
6770 jjtc000 = false;
6771 } else {
6772 jjtree.popNode();
6773 }
6774 if (jjte000 instanceof RuntimeException) {
6775 {if (true) throw (RuntimeException)jjte000;}
6776 }
6777 if (jjte000 instanceof ParseException) {
6778 {if (true) throw (ParseException)jjte000;}
6779 }
6780 {if (true) throw (Error)jjte000;}
6781 } finally {
6782 if (jjtc000) {
6783 jjtree.closeNodeScope(jjtn000, true);
6784 }
6785 }
6786 throw new Error("Missing return statement in function");
6787 }
6788
6789 final public ASTMethodDeclarator MethodDeclarator() throws ParseException {
6790
6791 ASTMethodDeclarator jjtn000 = new ASTMethodDeclarator(this, JJTMETHODDECLARATOR);
6792 boolean jjtc000 = true;
6793 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6794 try {
6795 switch (jj_nt.kind) {
6796 case FUNCTION:
6797 jj_consume_token(FUNCTION);
6798 simpleNode = ObjectNameDeclaration();
6799 switch (jj_nt.kind) {
6800 case 5:
6801 FormalParameters();
6802 break;
6803 default:
6804 jj_la1[77] = jj_gen;
6805 ;
6806 }
6807 Token nextToken;
6808 nextToken = getToken(1);
6809 if (!nextToken.image.equalsIgnoreCase("WRAPPED")
6810 &&
6811 !nextToken.image.equalsIgnoreCase("RETURN")
6812 )
6813 {
6814 {if (true) throw new ParseException("FUNCTION must RETURN a value or must be WRAPPED : found \u005c""
6815 + nextToken.image
6816 + "\u005c" at line "+nextToken.beginLine
6817 + ", column "+nextToken.beginColumn
6818 );}
6819 }
6820 switch (jj_nt.kind) {
6821 case RETURN:
6822 jj_consume_token(RETURN);
6823 Datatype();
6824 break;
6825 default:
6826 jj_la1[78] = jj_gen;
6827 ;
6828 }
6829 break;
6830 case PROCEDURE:
6831 jj_consume_token(PROCEDURE);
6832 simpleNode = ObjectNameDeclaration();
6833 switch (jj_nt.kind) {
6834 case 5:
6835 FormalParameters();
6836 break;
6837 default:
6838 jj_la1[79] = jj_gen;
6839 ;
6840 }
6841 break;
6842 default:
6843 jj_la1[80] = jj_gen;
6844 jj_consume_token(-1);
6845 throw new ParseException();
6846 }
6847 jjtree.closeNodeScope(jjtn000, true);
6848 jjtc000 = false;
6849 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
6850 } catch (Throwable jjte000) {
6851 if (jjtc000) {
6852 jjtree.clearNodeScope(jjtn000);
6853 jjtc000 = false;
6854 } else {
6855 jjtree.popNode();
6856 }
6857 if (jjte000 instanceof RuntimeException) {
6858 {if (true) throw (RuntimeException)jjte000;}
6859 }
6860 if (jjte000 instanceof ParseException) {
6861 {if (true) throw (ParseException)jjte000;}
6862 }
6863 {if (true) throw (Error)jjte000;}
6864 } finally {
6865 if (jjtc000) {
6866 jjtree.closeNodeScope(jjtn000, true);
6867 }
6868 }
6869 throw new Error("Missing return statement in function");
6870 }
6871
6872 final public ASTFormalParameters FormalParameters() throws ParseException {
6873
6874 ASTFormalParameters jjtn000 = new ASTFormalParameters(this, JJTFORMALPARAMETERS);
6875 boolean jjtc000 = true;
6876 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6877 StringBuilder sb = new StringBuilder();
6878 try {
6879 jj_consume_token(5);
6880 sb.append("(");
6881 switch (jj_nt.kind) {
6882 case REPLACE:
6883 case DEFINER:
6884 case CURRENT_USER:
6885 case SERIALLY_REUSABLE:
6886 case RESTRICT_REFERENCES:
6887 case EXCEPTION_INIT:
6888 case AUTONOMOUS_TRANSACTION:
6889 case LANGUAGE:
6890 case INLINE:
6891 case ADD:
6892 case AGGREGATE:
6893 case ALL:
6894 case ALTER:
6895 case AND:
6896 case ANY:
6897 case ARRAY:
6898 case AS:
6899 case ASC:
6900 case AT:
6901 case ATTRIBUTE:
6902 case AUTHID:
6903 case AVG:
6904 case BETWEEN:
6905 case BINARY_INTEGER:
6906 case BODY:
6907 case BOOLEAN:
6908 case BULK:
6909 case BY:
6910 case BYTE:
6911 case CASCADE:
6912 case CASE:
6913 case CHAR:
6914 case CHAR_BASE:
6915 case CHECK:
6916 case CLOSE:
6917 case CLUSTER:
6918 case COALESCE:
6919 case COLLECT:
6920 case COLUMN:
6921 case COMMENT:
6922 case COMMIT:
6923 case COMPRESS:
6924 case CONNECT:
6925 case CONSTANT:
6926 case CONSTRUCTOR:
6927 case CONTINUE:
6928 case CONVERT:
6929 case CREATE:
6930 case CURRENT:
6931 case CURRVAL:
6932 case CURSOR:
6933 case DATA:
6934 case DATE:
6935 case DAY:
6936 case DECLARE:
6937 case DECIMAL:
6938 case _DEFAULT:
6939 case DELETE:
6940 case DESC:
6941 case DISABLE:
6942 case DISTINCT:
6943 case DO:
6944 case DROP:
6945 case EDITIONABLE:
6946 case ELEMENT:
6947 case ELSE:
6948 case ELSIF:
6949 case ENABLE:
6950 case ESCAPE:
6951 case EXCEPT:
6952 case EXCEPTION:
6953 case EXCEPTIONS:
6954 case EXCLUSIVE:
6955 case EXECUTE:
6956 case EXISTS:
6957 case EXIT:
6958 case EXTERNAL:
6959 case EXTENDS:
6960 case EXTRACT:
6961 case FALSE:
6962 case FETCH:
6963 case FINAL:
6964 case FLOAT:
6965 case FOR:
6966 case FORALL:
6967 case FORCE:
6968 case FROM:
6969 case FUNCTION:
6970 case GLOBAL:
6971 case GOTO:
6972 case GROUP:
6973 case HASH:
6974 case HAVING:
6975 case HEAP:
6976 case HOUR:
6977 case IF:
6978 case IMMEDIATE:
6979 case IN:
6980 case INDEX:
6981 case INDICES:
6982 case INDEXTYPE:
6983 case INDICATOR:
6984 case INSERT:
6985 case INSTANTIABLE:
6986 case INTEGER:
6987 case INTERFACE:
6988 case INTERSECT:
6989 case INTERVAL:
6990 case INTO:
6991 case INVALIDATE:
6992 case IS:
6993 case ISOLATION:
6994 case JAVA:
6995 case LEVEL:
6996 case LIKE:
6997 case LIMIT:
6998 case LIMITED:
6999 case LOCK:
7000 case LONG:
7001 case LOOP:
7002 case MAP:
7003 case MAX:
7004 case MEMBER:
7005 case MERGE:
7006 case MIN:
7007 case MINUS:
7008 case MINUTE:
7009 case MLSLABEL:
7010 case MODIFY:
7011 case MOD:
7012 case MODE:
7013 case MONTH:
7014 case NATURAL:
7015 case NATURALN:
7016 case NEW:
7017 case NEXTVAL:
7018 case NO:
7019 case NOCOPY:
7020 case NONEDITIONABLE:
7021 case NOT:
7022 case NOWAIT:
7023 case NULL:
7024 case NULLIF:
7025 case NUMBER:
7026 case BFILE_BASE:
7027 case BLOB_BASE:
7028 case CLOB_BASE:
7029 case DATE_BASE:
7030 case NUMBER_BASE:
7031 case OBJECT:
7032 case OCIROWID:
7033 case OF:
7034 case OID:
7035 case ON:
7036 case OPAQUE:
7037 case OPEN:
7038 case OPERATOR:
7039 case OPTION:
7040 case OR:
7041 case ORDER:
7042 case ORGANIZATION:
7043 case OTHERS:
7044 case OUT:
7045 case OVERRIDING:
7046 case PACKAGE:
7047 case PARTITION:
7048 case PCTFREE:
7049 case PLS_INTEGER:
7050 case POSITIVE:
7051 case POSITIVEN:
7052 case PRESERVE:
7053 case PRIOR:
7054 case PROMPT:
7055 case PRIVATE:
7056 case PROCEDURE:
7057 case PUBLIC:
7058 case RAISE:
7059 case RANGE:
7060 case RAW:
7061 case REAL:
7062 case RECORD:
7063 case REF:
7064 case RELEASE:
7065 case RELIES_ON:
7066 case RENAME:
7067 case RESULT:
7068 case RETURN:
7069 case RETURNING:
7070 case REVERSE:
7071 case ROLLBACK:
7072 case ROW:
7073 case ROWS:
7074 case ROWID:
7075 case ROWNUM:
7076 case ROWTYPE:
7077 case SAVE:
7078 case SAVEPOINT:
7079 case SECOND:
7080 case SELECT:
7081 case SELF:
7082 case SEPARATE:
7083 case SET:
7084 case SHARE:
7085 case SMALLINT:
7086 case SPACE:
7087 case SQL:
7088 case SQLCODE:
7089 case SQLERRM:
7090 case START:
7091 case STATIC:
7092 case STDDEV:
7093 case SUBTYPE:
7094 case SUBSTITUTABLE:
7095 case SUCCESSFUL:
7096 case SUM:
7097 case SYNONYM:
7098 case SYSDATE:
7099 case SYS_REFCURSOR:
7100 case TABLE:
7101 case TEMPORARY:
7102 case THEN:
7103 case TIME:
7104 case TIMESTAMP:
7105 case TIMEZONE_REGION:
7106 case TIMEZONE_ABBR:
7107 case TIMEZONE_MINUTE:
7108 case TIMEZONE_HOUR:
7109 case TO:
7110 case TRANSACTION:
7111 case TRIGGER:
7112 case TRUE:
7113 case TYPE:
7114 case UI:
7115 case UNDER:
7116 case USING:
7117 case WHILE:
7118 case YES:
7119 case SHOW:
7120 case A:
7121 case UPDATE:
7122 case VARCHAR:
7123 case VARCHAR2:
7124 case DOUBLE:
7125 case DEC:
7126 case PRECISION:
7127 case INT:
7128 case NUMERIC:
7129 case SIGNTYPE:
7130 case NCHAR:
7131 case NVARCHAR2:
7132 case STRING:
7133 case UROWID:
7134 case VARRAY:
7135 case VARYING:
7136 case BFILE:
7137 case BLOB:
7138 case CLOB:
7139 case NCLOB:
7140 case YEAR:
7141 case LOCAL:
7142 case WITH:
7143 case ZONE:
7144 case CHARACTER:
7145 case AFTER:
7146 case BEFORE:
7147 case OLD:
7148 case PARENT:
7149 case ANALYZE:
7150 case ASSOCIATE:
7151 case AUDIT:
7152 case COMPOUND:
7153 case DATABASE:
7154 case CALL:
7155 case DDL:
7156 case DISASSOCIATE:
7157 case EACH:
7158 case FOLLOWS:
7159 case LOGOFF:
7160 case LOGON:
7161 case NESTED:
7162 case NOAUDIT:
7163 case SCHEMA:
7164 case SERVERERROR:
7165 case SHUTDOWN:
7166 case STARTUP:
7167 case STATEMENT:
7168 case STATISTICS:
7169 case SUSPEND:
7170 case TRUNCATE:
7171 case WRAPPED:
7172 case LIBRARY:
7173 case NAME:
7174 case STRUCT:
7175 case CONTEXT:
7176 case PARAMETERS:
7177 case LENGTH:
7178 case TDO:
7179 case MAXLEN:
7180 case CHARSETID:
7181 case CHARSETFORM:
7182 case ACCEPT:
7183 case ACCESSIBLE:
7184 case COPY:
7185 case DEFINE:
7186 case DISCONNECT:
7187 case HOST:
7188 case PRINT:
7189 case QUIT:
7190 case REMARK:
7191 case UNDEFINE:
7192 case VARIABLE:
7193 case WHENEVER:
7194 case ATTACH:
7195 case CAST:
7196 case TREAT:
7197 case TRIM:
7198 case LEFT:
7199 case RIGHT:
7200 case BOTH:
7201 case EMPTY:
7202 case MULTISET:
7203 case SUBMULTISET:
7204 case LEADING:
7205 case TRAILING:
7206 case CHAR_CS:
7207 case NCHAR_CS:
7208 case DBTIMEZONE:
7209 case SESSIONTIMEZONE:
7210 case AUTHENTICATED:
7211 case LINK:
7212 case SHARED:
7213 case DIRECTORY:
7214 case USER:
7215 case IDENTIFIER:
7216 case QUOTED_LITERAL:
7217 case SQLDATA_CLASS:
7218 case CUSTOMDATUM_CLASS:
7219 case ORADATA_CLASS:
7220 case JAVA_INTERFACE_CLASS:
7221 simpleNode = FormalParameter();
7222 sb.append(simpleNode.getImage());
7223 label_17:
7224 while (true) {
7225 switch (jj_nt.kind) {
7226 case 6:
7227 ;
7228 break;
7229 default:
7230 jj_la1[81] = jj_gen;
7231 break label_17;
7232 }
7233 jj_consume_token(6);
7234 simpleNode = FormalParameter();
7235 sb.append(","+simpleNode.getImage());
7236 }
7237 break;
7238 default:
7239 jj_la1[82] = jj_gen;
7240 ;
7241 }
7242 jj_consume_token(7);
7243 sb.append(")");
7244 jjtree.closeNodeScope(jjtn000, true);
7245 jjtc000 = false;
7246 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
7247 } catch (Throwable jjte000) {
7248 if (jjtc000) {
7249 jjtree.clearNodeScope(jjtn000);
7250 jjtc000 = false;
7251 } else {
7252 jjtree.popNode();
7253 }
7254 if (jjte000 instanceof RuntimeException) {
7255 {if (true) throw (RuntimeException)jjte000;}
7256 }
7257 if (jjte000 instanceof ParseException) {
7258 {if (true) throw (ParseException)jjte000;}
7259 }
7260 {if (true) throw (Error)jjte000;}
7261 } finally {
7262 if (jjtc000) {
7263 jjtree.closeNodeScope(jjtn000, true);
7264 }
7265 }
7266 throw new Error("Missing return statement in function");
7267 }
7268
7269 final public ASTVariableOrConstantDeclarator VariableOrConstantDeclarator() throws ParseException {
7270
7271 ASTVariableOrConstantDeclarator jjtn000 = new ASTVariableOrConstantDeclarator(this, JJTVARIABLEORCONSTANTDECLARATOR);
7272 boolean jjtc000 = true;
7273 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7274 StringBuilder sb = new StringBuilder();
7275 try {
7276 simpleNode = VariableOrConstantDeclaratorId();
7277 sb.append(simpleNode.getImage());
7278 if (jj_2_26(2)) {
7279 jj_consume_token(CONSTANT);
7280 sb.append(" " + token.image);
7281 } else {
7282 ;
7283 }
7284 simpleNode = Datatype();
7285 sb.append(" " + simpleNode.getImage());
7286 switch (jj_nt.kind) {
7287 case NOT:
7288 case NULL:
7289 switch (jj_nt.kind) {
7290 case NOT:
7291 jj_consume_token(NOT);
7292 sb.append(" " + token.image);
7293 break;
7294 default:
7295 jj_la1[83] = jj_gen;
7296 ;
7297 }
7298 jj_consume_token(NULL);
7299 sb.append(" " + token.image);
7300 break;
7301 default:
7302 jj_la1[84] = jj_gen;
7303 ;
7304 }
7305 switch (jj_nt.kind) {
7306 case 9:
7307 case _DEFAULT:
7308 switch (jj_nt.kind) {
7309 case 9:
7310 jj_consume_token(9);
7311 jj_consume_token(10);
7312 sb.append(" :=");
7313 break;
7314 case _DEFAULT:
7315 jj_consume_token(_DEFAULT);
7316 sb.append(" " + token.image);
7317 break;
7318 default:
7319 jj_la1[85] = jj_gen;
7320 jj_consume_token(-1);
7321 throw new ParseException();
7322 }
7323 simpleNode = VariableOrConstantInitializer();
7324 sb.append(" " + simpleNode.getImage());
7325 break;
7326 default:
7327 jj_la1[86] = jj_gen;
7328 ;
7329 }
7330 jjtree.closeNodeScope(jjtn000, true);
7331 jjtc000 = false;
7332 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
7333 } catch (Throwable jjte000) {
7334 if (jjtc000) {
7335 jjtree.clearNodeScope(jjtn000);
7336 jjtc000 = false;
7337 } else {
7338 jjtree.popNode();
7339 }
7340 if (jjte000 instanceof RuntimeException) {
7341 {if (true) throw (RuntimeException)jjte000;}
7342 }
7343 if (jjte000 instanceof ParseException) {
7344 {if (true) throw (ParseException)jjte000;}
7345 }
7346 {if (true) throw (Error)jjte000;}
7347 } finally {
7348 if (jjtc000) {
7349 jjtree.closeNodeScope(jjtn000, true);
7350 }
7351 }
7352 throw new Error("Missing return statement in function");
7353 }
7354
7355 final public ASTVariableOrConstantDeclaratorId VariableOrConstantDeclaratorId() throws ParseException {
7356
7357 ASTVariableOrConstantDeclaratorId jjtn000 = new ASTVariableOrConstantDeclaratorId(this, JJTVARIABLEORCONSTANTDECLARATORID);
7358 boolean jjtc000 = true;
7359 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7360 try {
7361 simpleNode = ID();
7362 jjtree.closeNodeScope(jjtn000, true);
7363 jjtc000 = false;
7364 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
7365 } catch (Throwable jjte000) {
7366 if (jjtc000) {
7367 jjtree.clearNodeScope(jjtn000);
7368 jjtc000 = false;
7369 } else {
7370 jjtree.popNode();
7371 }
7372 if (jjte000 instanceof RuntimeException) {
7373 {if (true) throw (RuntimeException)jjte000;}
7374 }
7375 if (jjte000 instanceof ParseException) {
7376 {if (true) throw (ParseException)jjte000;}
7377 }
7378 {if (true) throw (Error)jjte000;}
7379 } finally {
7380 if (jjtc000) {
7381 jjtree.closeNodeScope(jjtn000, true);
7382 }
7383 }
7384 throw new Error("Missing return statement in function");
7385 }
7386
7387 final public ASTVariableOrConstantInitializer VariableOrConstantInitializer() throws ParseException {
7388
7389 ASTVariableOrConstantInitializer jjtn000 = new ASTVariableOrConstantInitializer(this, JJTVARIABLEORCONSTANTINITIALIZER);
7390 boolean jjtc000 = true;
7391 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7392 try {
7393 simpleNode = Expression();
7394 jjtree.closeNodeScope(jjtn000, true);
7395 jjtc000 = false;
7396 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
7397 } catch (Throwable jjte000) {
7398 if (jjtc000) {
7399 jjtree.clearNodeScope(jjtn000);
7400 jjtc000 = false;
7401 } else {
7402 jjtree.popNode();
7403 }
7404 if (jjte000 instanceof RuntimeException) {
7405 {if (true) throw (RuntimeException)jjte000;}
7406 }
7407 if (jjte000 instanceof ParseException) {
7408 {if (true) throw (ParseException)jjte000;}
7409 }
7410 {if (true) throw (Error)jjte000;}
7411 } finally {
7412 if (jjtc000) {
7413 jjtree.closeNodeScope(jjtn000, true);
7414 }
7415 }
7416 throw new Error("Missing return statement in function");
7417 }
7418
7419 final public ASTDatatype Datatype() throws ParseException {
7420
7421 ASTDatatype jjtn000 = new ASTDatatype(this, JJTDATATYPE);
7422 boolean jjtc000 = true;
7423 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7424 StringBuilder sb = new StringBuilder();
7425 try {
7426 switch (jj_nt.kind) {
7427 case CC_IF:
7428
7429 simpleNode = CompilationDataType();
7430 sb.append(simpleNode.getImage());
7431 break;
7432 default:
7433 jj_la1[90] = jj_gen;
7434 if (jj_2_28(2)) {
7435 simpleNode = ScalarDataTypeName();
7436 sb.append(simpleNode.getImage());
7437 } else {
7438 switch (jj_nt.kind) {
7439 case REPLACE:
7440 case DEFINER:
7441 case CURRENT_USER:
7442 case LANGUAGE:
7443 case INLINE:
7444 case ADD:
7445 case AGGREGATE:
7446 case ARRAY:
7447 case AT:
7448 case ATTRIBUTE:
7449 case AUTHID:
7450 case BODY:
7451 case BULK:
7452 case BYTE:
7453 case CASCADE:
7454 case CLOSE:
7455 case COALESCE:
7456 case COLLECT:
7457 case COLUMN:
7458 case COMMENT:
7459 case COMMIT:
7460 case CONSTRUCTOR:
7461 case CONTINUE:
7462 case CONVERT:
7463 case CURRENT:
7464 case CURSOR:
7465 case DATA:
7466 case DAY:
7467 case DISABLE:
7468 case EDITIONABLE:
7469 case ELEMENT:
7470 case ENABLE:
7471 case ESCAPE:
7472 case EXCEPT:
7473 case EXCEPTIONS:
7474 case EXIT:
7475 case EXTERNAL:
7476 case EXTENDS:
7477 case EXTRACT:
7478 case FALSE:
7479 case FINAL:
7480 case FORCE:
7481 case FUNCTION:
7482 case GLOBAL:
7483 case HASH:
7484 case HEAP:
7485 case HOUR:
7486 case IMMEDIATE:
7487 case INDICES:
7488 case INDEXTYPE:
7489 case INDICATOR:
7490 case INSTANTIABLE:
7491 case INTERVAL:
7492 case INVALIDATE:
7493 case ISOLATION:
7494 case JAVA:
7495 case LEVEL:
7496 case LIMIT:
7497 case LOOP:
7498 case MAP:
7499 case MAX:
7500 case MEMBER:
7501 case MERGE:
7502 case MIN:
7503 case MINUTE:
7504 case MLSLABEL:
7505 case MODIFY:
7506 case MOD:
7507 case MONTH:
7508 case NATURAL:
7509 case NEW:
7510 case NO:
7511 case NONEDITIONABLE:
7512 case NULLIF:
7513 case OBJECT:
7514 case OID:
7515 case OPAQUE:
7516 case OPEN:
7517 case OPERATOR:
7518 case ORGANIZATION:
7519 case OTHERS:
7520 case OVERRIDING:
7521 case PACKAGE:
7522 case PARTITION:
7523 case PRESERVE:
7524 case PRIVATE:
7525 case PROCEDURE:
7526 case RANGE:
7527 case RAW:
7528 case REAL:
7529 case RECORD:
7530 case REF:
7531 case RELEASE:
7532 case RELIES_ON:
7533 case RENAME:
7534 case RESULT:
7535 case RETURN:
7536 case RETURNING:
7537 case REVERSE:
7538 case ROLLBACK:
7539 case ROW:
7540 case ROWS:
7541 case ROWID:
7542 case ROWNUM:
7543 case SAVE:
7544 case SAVEPOINT:
7545 case SECOND:
7546 case SELF:
7547 case SET:
7548 case SPACE:
7549 case SQL:
7550 case SQLCODE:
7551 case SQLERRM:
7552 case STATIC:
7553 case SUBTYPE:
7554 case SUBSTITUTABLE:
7555 case SUCCESSFUL:
7556 case SYSDATE:
7557 case SYS_REFCURSOR:
7558 case TEMPORARY:
7559 case TIME:
7560 case TIMESTAMP:
7561 case TIMEZONE_REGION:
7562 case TIMEZONE_ABBR:
7563 case TIMEZONE_MINUTE:
7564 case TIMEZONE_HOUR:
7565 case TRANSACTION:
7566 case TRUE:
7567 case TYPE:
7568 case UNDER:
7569 case USING:
7570 case YES:
7571 case SHOW:
7572 case A:
7573 case DOUBLE:
7574 case DEC:
7575 case PRECISION:
7576 case INT:
7577 case NUMERIC:
7578 case NCHAR:
7579 case NVARCHAR2:
7580 case STRING:
7581 case UROWID:
7582 case VARRAY:
7583 case VARYING:
7584 case BFILE:
7585 case BLOB:
7586 case CLOB:
7587 case NCLOB:
7588 case YEAR:
7589 case LOCAL:
7590 case ZONE:
7591 case CHARACTER:
7592 case AFTER:
7593 case BEFORE:
7594 case OLD:
7595 case PARENT:
7596 case ANALYZE:
7597 case ASSOCIATE:
7598 case AUDIT:
7599 case COMPOUND:
7600 case DATABASE:
7601 case CALL:
7602 case DDL:
7603 case DISASSOCIATE:
7604 case EACH:
7605 case FOLLOWS:
7606 case LOGOFF:
7607 case LOGON:
7608 case NESTED:
7609 case NOAUDIT:
7610 case SCHEMA:
7611 case SERVERERROR:
7612 case SHUTDOWN:
7613 case STARTUP:
7614 case STATEMENT:
7615 case STATISTICS:
7616 case SUSPEND:
7617 case TRUNCATE:
7618 case WRAPPED:
7619 case LIBRARY:
7620 case NAME:
7621 case STRUCT:
7622 case CONTEXT:
7623 case PARAMETERS:
7624 case LENGTH:
7625 case TDO:
7626 case MAXLEN:
7627 case CHARSETID:
7628 case CHARSETFORM:
7629 case ACCEPT:
7630 case ACCESSIBLE:
7631 case COPY:
7632 case DEFINE:
7633 case DISCONNECT:
7634 case HOST:
7635 case PRINT:
7636 case QUIT:
7637 case REMARK:
7638 case UNDEFINE:
7639 case VARIABLE:
7640 case WHENEVER:
7641 case ATTACH:
7642 case CAST:
7643 case TREAT:
7644 case TRIM:
7645 case LEFT:
7646 case RIGHT:
7647 case BOTH:
7648 case EMPTY:
7649 case MULTISET:
7650 case SUBMULTISET:
7651 case LEADING:
7652 case TRAILING:
7653 case CHAR_CS:
7654 case NCHAR_CS:
7655 case DBTIMEZONE:
7656 case SESSIONTIMEZONE:
7657 case AUTHENTICATED:
7658 case LINK:
7659 case SHARED:
7660 case DIRECTORY:
7661 case USER:
7662 case IDENTIFIER:
7663 case QUOTED_LITERAL:
7664 if (jj_2_27(2)) {
7665 jj_consume_token(REF);
7666 sb.append(token.image);
7667 } else {
7668 ;
7669 }
7670 simpleNode = QualifiedName();
7671 sb.append(simpleNode.getImage());
7672 switch (jj_nt.kind) {
7673 case 2:
7674 jj_consume_token(2);
7675 simpleNode = QualifiedName();
7676 sb.append("@"+simpleNode.getImage());
7677 break;
7678 default:
7679 jj_la1[87] = jj_gen;
7680 ;
7681 }
7682 switch (jj_nt.kind) {
7683 case 11:
7684 jj_consume_token(11);
7685 switch (jj_nt.kind) {
7686 case TYPE:
7687 jj_consume_token(TYPE);
7688 break;
7689 case ROWTYPE:
7690 jj_consume_token(ROWTYPE);
7691 break;
7692 default:
7693 jj_la1[88] = jj_gen;
7694 jj_consume_token(-1);
7695 throw new ParseException();
7696 }
7697 sb.append("%"+token.image);
7698 break;
7699 default:
7700 jj_la1[89] = jj_gen;
7701 ;
7702 }
7703 break;
7704 default:
7705 jj_la1[91] = jj_gen;
7706 jj_consume_token(-1);
7707 throw new ParseException();
7708 }
7709 }
7710 }
7711 jjtree.closeNodeScope(jjtn000, true);
7712 jjtc000 = false;
7713 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000;}
7714 } catch (Throwable jjte000) {
7715 if (jjtc000) {
7716 jjtree.clearNodeScope(jjtn000);
7717 jjtc000 = false;
7718 } else {
7719 jjtree.popNode();
7720 }
7721 if (jjte000 instanceof RuntimeException) {
7722 {if (true) throw (RuntimeException)jjte000;}
7723 }
7724 if (jjte000 instanceof ParseException) {
7725 {if (true) throw (ParseException)jjte000;}
7726 }
7727 {if (true) throw (Error)jjte000;}
7728 } finally {
7729 if (jjtc000) {
7730 jjtree.closeNodeScope(jjtn000, true);
7731 }
7732 }
7733 throw new Error("Missing return statement in function");
7734 }
7735
7736 final public ASTCompilationDataType CompilationDataType() throws ParseException {
7737
7738 ASTCompilationDataType jjtn000 = new ASTCompilationDataType(this, JJTCOMPILATIONDATATYPE);
7739 boolean jjtc000 = true;
7740 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
7741 StringBuilder sb = new StringBuilder() ;
7742 try {
7743 jj_consume_token(CC_IF);
7744 sb.append(" "); sb.append(token.image) ;
7745 simpleNode = ConditionalOrExpression();
7746 sb.append(" "); sb.append(simpleNode.getImage());
7747 jj_consume_token(CC_THEN);
7748 sb.append(" "); sb.append(token.image);
7749 simpleNode = Datatype();
7750 sb.append(" "); sb.append(simpleNode.getImage());
7751 label_18:
7752 while (true) {
7753 switch (jj_nt.kind) {
7754 case CC_ELSIF:
7755 ;
7756 break;
7757 default:
7758 jj_la1[92] = jj_gen;
7759 break label_18;
7760 }
7761 jj_consume_token(CC_ELSIF);
7762 sb.append(" "); sb.append(token.image);
7763 simpleNode = ConditionalOrExpression();
7764 sb.append(" "); sb.append(simpleNode.getImage());
7765 jj_consume_token(CC_THEN);
7766 sb.append(" "); sb.append(token.image);
7767 simpleNode = Datatype();
7768 sb.append(" "); sb.append(simpleNode.getImage());
7769 }
7770 label_19:
7771 while (true) {
7772 switch (jj_nt.kind) {
7773 case CC_ELSE:
7774 ;
7775 break;
7776 default:
7777 jj_la1[93] = jj_gen;
7778 break label_19;
7779 }
7780 jj_consume_token(CC_ELSE);
7781 sb.append(" "); sb.append(token.image);
7782 simpleNode = Datatype();
7783 sb.append(" "); sb.append(simpleNode.getImage());
7784 }
7785 jj_consume_token(CC_END);
7786 sb.append(" "); sb.append(token.image);
7787 jjtree.closeNodeScope(jjtn000, true);
7788 jjtc000 = false;
7789 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000;}
7790 } catch (Throwable jjte000) {
7791 if (jjtc000) {
7792 jjtree.clearNodeScope(jjtn000);
7793 jjtc000 = false;
7794 } else {
7795 jjtree.popNode();
7796 }
7797 if (jjte000 instanceof RuntimeException) {
7798 {if (true) throw (RuntimeException)jjte000;}
7799 }
7800 if (jjte000 instanceof ParseException) {
7801 {if (true) throw (ParseException)jjte000;}
7802 }
7803 {if (true) throw (Error)jjte000;}
7804 } finally {
7805 if (jjtc000) {
7806 jjtree.closeNodeScope(jjtn000, true);
7807 }
7808 }
7809 throw new Error("Missing return statement in function");
7810 }
7811
7812 final public ASTCollectionTypeName CollectionTypeName() throws ParseException {
7813
7814 ASTCollectionTypeName jjtn000 = new ASTCollectionTypeName(this, JJTCOLLECTIONTYPENAME);
7815 boolean jjtc000 = true;
7816 jjtree.openNodeScope(jjtn000);PLSQLNode size=null, precision=null;
7817 StringBuilder sb = new StringBuilder();
7818 try {
7819 switch (jj_nt.kind) {
7820 case TABLE:
7821 jj_consume_token(TABLE);
7822 break;
7823 case VARRAY:
7824 jj_consume_token(VARRAY);
7825 break;
7826 case VARYING:
7827 jj_consume_token(VARYING);
7828 jj_consume_token(ARRAY);
7829 sb.append( "VARYING ARRAY") ;
7830 break;
7831 default:
7832 jj_la1[94] = jj_gen;
7833 jj_consume_token(-1);
7834 throw new ParseException();
7835 }
7836 if (sb.length() == 0) {
7837 sb.append(token.toString());
7838 }
7839 if (jj_2_29(2)) {
7840 jj_consume_token(5);
7841 size = NumericLiteral();
7842 sb.append( "(" + size);
7843 switch (jj_nt.kind) {
7844 case 6:
7845 jj_consume_token(6);
7846 precision = NumericLiteral();
7847 sb.append( "," + precision);
7848 break;
7849 default:
7850 jj_la1[95] = jj_gen;
7851 ;
7852 }
7853 switch (jj_nt.kind) {
7854 case CHAR:
7855 jj_consume_token(CHAR);
7856 sb.append( " CHAR") ;
7857 break;
7858 default:
7859 jj_la1[96] = jj_gen;
7860 ;
7861 }
7862 switch (jj_nt.kind) {
7863 case BYTE:
7864 jj_consume_token(BYTE);
7865 sb.append( " BYTE") ;
7866 break;
7867 default:
7868 jj_la1[97] = jj_gen;
7869 ;
7870 }
7871 jj_consume_token(7);
7872 sb.append( ")");
7873 } else {
7874 ;
7875 }
7876 jjtree.closeNodeScope(jjtn000, true);
7877 jjtc000 = false;
7878 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000;}
7879 } catch (Throwable jjte000) {
7880 if (jjtc000) {
7881 jjtree.clearNodeScope(jjtn000);
7882 jjtc000 = false;
7883 } else {
7884 jjtree.popNode();
7885 }
7886 if (jjte000 instanceof RuntimeException) {
7887 {if (true) throw (RuntimeException)jjte000;}
7888 }
7889 if (jjte000 instanceof ParseException) {
7890 {if (true) throw (ParseException)jjte000;}
7891 }
7892 {if (true) throw (Error)jjte000;}
7893 } finally {
7894 if (jjtc000) {
7895 jjtree.closeNodeScope(jjtn000, true);
7896 }
7897 }
7898 throw new Error("Missing return statement in function");
7899 }
7900
7901 final public ASTScalarDataTypeName ScalarDataTypeName() throws ParseException {
7902
7903 ASTScalarDataTypeName jjtn000 = new ASTScalarDataTypeName(this, JJTSCALARDATATYPENAME);
7904 boolean jjtc000 = true;
7905 jjtree.openNodeScope(jjtn000);PLSQLNode size=null, precision=null ;
7906 StringBuilder name = new StringBuilder();
7907 PLSQLNode characterSet = null;
7908 try {
7909 switch (jj_nt.kind) {
7910 case BFILE_BASE:
7911 jj_consume_token(BFILE_BASE);
7912 break;
7913 case BLOB_BASE:
7914 jj_consume_token(BLOB_BASE);
7915 break;
7916 case CHAR_BASE:
7917 jj_consume_token(CHAR_BASE);
7918 break;
7919 case CLOB_BASE:
7920 jj_consume_token(CLOB_BASE);
7921 break;
7922 case DATE_BASE:
7923 jj_consume_token(DATE_BASE);
7924 break;
7925 case NUMBER_BASE:
7926 jj_consume_token(NUMBER_BASE);
7927 break;
7928 case BINARY_INTEGER:
7929 jj_consume_token(BINARY_INTEGER);
7930 break;
7931 case DEC:
7932 jj_consume_token(DEC);
7933 break;
7934 case DECIMAL:
7935 jj_consume_token(DECIMAL);
7936 break;
7937 case DOUBLE:
7938 jj_consume_token(DOUBLE);
7939 jj_consume_token(PRECISION);
7940 name.append("DOUBLE PRECISION");
7941 break;
7942 case FLOAT:
7943 jj_consume_token(FLOAT);
7944 break;
7945 case INT:
7946 jj_consume_token(INT);
7947 break;
7948 case INTEGER:
7949 jj_consume_token(INTEGER);
7950 break;
7951 case NATURAL:
7952 jj_consume_token(NATURAL);
7953 break;
7954 case NATURALN:
7955 jj_consume_token(NATURALN);
7956 break;
7957 case NUMBER:
7958 jj_consume_token(NUMBER);
7959 break;
7960 case NUMERIC:
7961 jj_consume_token(NUMERIC);
7962 break;
7963 case PLS_INTEGER:
7964 jj_consume_token(PLS_INTEGER);
7965 break;
7966 case POSITIVE:
7967 jj_consume_token(POSITIVE);
7968 break;
7969 case POSITIVEN:
7970 jj_consume_token(POSITIVEN);
7971 break;
7972 case REAL:
7973 jj_consume_token(REAL);
7974 break;
7975 case SIGNTYPE:
7976 jj_consume_token(SIGNTYPE);
7977 break;
7978 case SMALLINT:
7979 jj_consume_token(SMALLINT);
7980 break;
7981 case CHAR:
7982 case LONG:
7983 case RAW:
7984 case ROWID:
7985 case VARCHAR:
7986 case VARCHAR2:
7987 case NCHAR:
7988 case NVARCHAR2:
7989 case STRING:
7990 case UROWID:
7991 case CLOB:
7992 case NCLOB:
7993 case CHARACTER:
7994 switch (jj_nt.kind) {
7995 case CHAR:
7996 jj_consume_token(CHAR);
7997 break;
7998 case CHARACTER:
7999 jj_consume_token(CHARACTER);
8000 break;
8001 default:
8002 jj_la1[98] = jj_gen;
8003 if (jj_2_30(2)) {
8004 jj_consume_token(LONG);
8005 jj_consume_token(RAW);
8006 name.append("LONG RAW");
8007 } else {
8008 switch (jj_nt.kind) {
8009 case LONG:
8010 jj_consume_token(LONG);
8011 break;
8012 case NCHAR:
8013 jj_consume_token(NCHAR);
8014 break;
8015 case NVARCHAR2:
8016 jj_consume_token(NVARCHAR2);
8017 break;
8018 case RAW:
8019 jj_consume_token(RAW);
8020 break;
8021 case ROWID:
8022 jj_consume_token(ROWID);
8023 break;
8024 case STRING:
8025 jj_consume_token(STRING);
8026 break;
8027 case UROWID:
8028 jj_consume_token(UROWID);
8029 break;
8030 case VARCHAR:
8031 jj_consume_token(VARCHAR);
8032 break;
8033 case VARCHAR2:
8034 jj_consume_token(VARCHAR2);
8035 break;
8036 case CLOB:
8037 jj_consume_token(CLOB);
8038 break;
8039 case NCLOB:
8040 jj_consume_token(NCLOB);
8041 break;
8042 default:
8043 jj_la1[99] = jj_gen;
8044 jj_consume_token(-1);
8045 throw new ParseException();
8046 }
8047 }
8048 }
8049 break;
8050 case BOOLEAN:
8051 jj_consume_token(BOOLEAN);
8052 break;
8053 case BFILE:
8054 jj_consume_token(BFILE);
8055 break;
8056 case BLOB:
8057 jj_consume_token(BLOB);
8058 break;
8059 case SYS_REFCURSOR:
8060 jj_consume_token(SYS_REFCURSOR);
8061 break;
8062 case REF:
8063 jj_consume_token(REF);
8064 jj_consume_token(CURSOR);
8065 name.append("REF CURSOR");
8066 break;
8067 case DATE:
8068 jj_consume_token(DATE);
8069 break;
8070 default:
8071 jj_la1[100] = jj_gen;
8072 if (jj_2_31(2)) {
8073 jj_consume_token(INTERVAL);
8074 jj_consume_token(YEAR);
8075 name.append("INTERVAL YEAR");
8076 } else if (jj_2_32(2)) {
8077 jj_consume_token(INTERVAL);
8078 jj_consume_token(DAY);
8079 name.append("INTERVAL DAY");
8080 } else {
8081 switch (jj_nt.kind) {
8082 case TIME:
8083 jj_consume_token(TIME);
8084 break;
8085 case TIMESTAMP:
8086 jj_consume_token(TIMESTAMP);
8087 break;
8088 case SELF:
8089 jj_consume_token(SELF);
8090 jj_consume_token(AS);
8091 jj_consume_token(RESULT);
8092 name.append("SELF AS RESULT");
8093 break;
8094 default:
8095 jj_la1[101] = jj_gen;
8096 jj_consume_token(-1);
8097 throw new ParseException();
8098 }
8099 }
8100 }
8101 if (name.length() == 0 ) {
8102 name.append(token.toString());
8103 }
8104 if (jj_2_33(2)) {
8105 jj_consume_token(5);
8106 size = NumericLiteral();
8107 name.append("("); name.append(size.getImage()) ;
8108 switch (jj_nt.kind) {
8109 case 6:
8110 jj_consume_token(6);
8111 precision = UnaryExpression(true);
8112 name.append(",") ; name.append(precision.getImage()) ;
8113 break;
8114 default:
8115 jj_la1[102] = jj_gen;
8116 ;
8117 }
8118 switch (jj_nt.kind) {
8119 case CHAR:
8120 jj_consume_token(CHAR);
8121 name.append(" CHAR") ;
8122 break;
8123 default:
8124 jj_la1[103] = jj_gen;
8125 ;
8126 }
8127 switch (jj_nt.kind) {
8128 case BYTE:
8129 jj_consume_token(BYTE);
8130 name.append(" BYTE") ;
8131 break;
8132 default:
8133 jj_la1[104] = jj_gen;
8134 ;
8135 }
8136 jj_consume_token(7);
8137 name.append( ")") ;
8138 } else {
8139 ;
8140 }
8141 switch (jj_nt.kind) {
8142 case TO:
8143 case WITH:
8144 case CHARACTER:
8145 switch (jj_nt.kind) {
8146 case CHARACTER:
8147 jj_consume_token(CHARACTER);
8148 jj_consume_token(SET);
8149 characterSet = Name();
8150 name.append( " CHARACTER SET ") ; name.append(characterSet.getImage()) ;
8151 break;
8152 default:
8153 jj_la1[105] = jj_gen;
8154 if (jj_2_35(4)) {
8155 jj_consume_token(WITH);
8156 jj_consume_token(LOCAL);
8157 jj_consume_token(TIME);
8158 jj_consume_token(ZONE);
8159 name.append(" WITH LOCAL TIME ZONE");
8160 } else if (jj_2_36(3)) {
8161 jj_consume_token(WITH);
8162 jj_consume_token(TIME);
8163 jj_consume_token(ZONE);
8164 name.append( " WITH TIME ZONE");
8165 } else if (jj_2_37(2)) {
8166 jj_consume_token(TO);
8167 jj_consume_token(MONTH);
8168 name.append( " TO MONTH");
8169 } else if (jj_2_38(2)) {
8170 jj_consume_token(TO);
8171 jj_consume_token(SECOND);
8172 name.append( " TO SECOND");
8173 if (jj_2_34(2)) {
8174 jj_consume_token(5);
8175 precision = NumericLiteral();
8176 name.append( "(" + precision) ;
8177 jj_consume_token(7);
8178 name.append( ")");
8179 } else {
8180 ;
8181 }
8182 } else {
8183 jj_consume_token(-1);
8184 throw new ParseException();
8185 }
8186 }
8187 break;
8188 default:
8189 jj_la1[106] = jj_gen;
8190 ;
8191 }
8192 jjtree.closeNodeScope(jjtn000, true);
8193 jjtc000 = false;
8194 jjtn000.setImage(name.toString()) ; {if (true) return jjtn000;}
8195 } catch (Throwable jjte000) {
8196 if (jjtc000) {
8197 jjtree.clearNodeScope(jjtn000);
8198 jjtc000 = false;
8199 } else {
8200 jjtree.popNode();
8201 }
8202 if (jjte000 instanceof RuntimeException) {
8203 {if (true) throw (RuntimeException)jjte000;}
8204 }
8205 if (jjte000 instanceof ParseException) {
8206 {if (true) throw (ParseException)jjte000;}
8207 }
8208 {if (true) throw (Error)jjte000;}
8209 } finally {
8210 if (jjtc000) {
8211 jjtree.closeNodeScope(jjtn000, true);
8212 }
8213 }
8214 throw new Error("Missing return statement in function");
8215 }
8216
8217 final public ASTDateTimeLiteral DateTimeLiteral() throws ParseException {
8218
8219 ASTDateTimeLiteral jjtn000 = new ASTDateTimeLiteral(this, JJTDATETIMELITERAL);
8220 boolean jjtc000 = true;
8221 jjtree.openNodeScope(jjtn000);Token t = null ;
8222 PLSQLNode simpleNode = null ;
8223 StringBuilder sb = new StringBuilder() ;
8224 try {
8225 switch (jj_nt.kind) {
8226 case INTERVAL:
8227 jj_consume_token(INTERVAL);
8228 break;
8229 case TIMESTAMP:
8230 jj_consume_token(TIMESTAMP);
8231 break;
8232 case DATE:
8233 jj_consume_token(DATE);
8234 break;
8235 default:
8236 jj_la1[107] = jj_gen;
8237 jj_consume_token(-1);
8238 throw new ParseException();
8239 }
8240 sb.append(token.image);
8241 switch (jj_nt.kind) {
8242 case CHARACTER_LITERAL:
8243 jj_consume_token(CHARACTER_LITERAL);
8244 sb.append(" "); sb.append(token.image);
8245 break;
8246 case STRING_LITERAL:
8247 simpleNode = StringLiteral();
8248 sb.append(" "); sb.append(simpleNode.getImage());
8249 break;
8250 default:
8251 jj_la1[108] = jj_gen;
8252 jj_consume_token(-1);
8253 throw new ParseException();
8254 }
8255 switch (jj_nt.kind) {
8256 case DAY:
8257 case HOUR:
8258 case MINUTE:
8259 case MONTH:
8260 case SECOND:
8261 case YEAR:
8262 switch (jj_nt.kind) {
8263 case YEAR:
8264 jj_consume_token(YEAR);
8265 break;
8266 case MONTH:
8267 jj_consume_token(MONTH);
8268 break;
8269 case DAY:
8270 jj_consume_token(DAY);
8271 break;
8272 case HOUR:
8273 jj_consume_token(HOUR);
8274 break;
8275 case MINUTE:
8276 jj_consume_token(MINUTE);
8277 break;
8278 case SECOND:
8279 jj_consume_token(SECOND);
8280 break;
8281 default:
8282 jj_la1[109] = jj_gen;
8283 jj_consume_token(-1);
8284 throw new ParseException();
8285 }
8286 break;
8287 default:
8288 jj_la1[110] = jj_gen;
8289 ;
8290 }
8291 if (null != t)
8292 {
8293 sb.append(" "); sb.append(token.image);
8294 t = null;
8295 }
8296 if (jj_2_39(2)) {
8297 jj_consume_token(5);
8298 simpleNode = NumericLiteral();
8299 sb.append("("); sb.append(simpleNode.getImage());
8300 jj_consume_token(7);
8301 sb.append("}");
8302 } else {
8303 ;
8304 }
8305 switch (jj_nt.kind) {
8306 case TO:
8307 case WITH:
8308 switch (jj_nt.kind) {
8309 case WITH:
8310 jj_consume_token(WITH);
8311 sb.append(" "); sb.append(token.toString()) ;
8312 switch (jj_nt.kind) {
8313 case LOCAL:
8314 jj_consume_token(LOCAL);
8315 sb.append(" "); sb.append(token.toString()) ;
8316 break;
8317 default:
8318 jj_la1[111] = jj_gen;
8319 ;
8320 }
8321 jj_consume_token(TIME);
8322 jj_consume_token(ZONE);
8323 sb.append(" "); sb.append("TIME ZONE") ;
8324 break;
8325 case TO:
8326 jj_consume_token(TO);
8327 sb.append(" "); sb.append(token.toString()) ;
8328 switch (jj_nt.kind) {
8329 case YEAR:
8330 jj_consume_token(YEAR);
8331 break;
8332 case MONTH:
8333 jj_consume_token(MONTH);
8334 break;
8335 case DAY:
8336 jj_consume_token(DAY);
8337 break;
8338 case HOUR:
8339 jj_consume_token(HOUR);
8340 break;
8341 case MINUTE:
8342 jj_consume_token(MINUTE);
8343 break;
8344 case SECOND:
8345 jj_consume_token(SECOND);
8346 break;
8347 default:
8348 jj_la1[112] = jj_gen;
8349 jj_consume_token(-1);
8350 throw new ParseException();
8351 }
8352 sb.append(token.image);
8353 if (jj_2_40(2)) {
8354 jj_consume_token(5);
8355 simpleNode = NumericLiteral();
8356 sb.append("("); sb.append(simpleNode.getImage());
8357 jj_consume_token(7);
8358 sb.append("}");
8359 } else {
8360 ;
8361 }
8362 break;
8363 default:
8364 jj_la1[113] = jj_gen;
8365 jj_consume_token(-1);
8366 throw new ParseException();
8367 }
8368 break;
8369 default:
8370 jj_la1[114] = jj_gen;
8371 ;
8372 }
8373 jjtree.closeNodeScope(jjtn000, true);
8374 jjtc000 = false;
8375 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
8376 } catch (Throwable jjte000) {
8377 if (jjtc000) {
8378 jjtree.clearNodeScope(jjtn000);
8379 jjtc000 = false;
8380 } else {
8381 jjtree.popNode();
8382 }
8383 if (jjte000 instanceof RuntimeException) {
8384 {if (true) throw (RuntimeException)jjte000;}
8385 }
8386 if (jjte000 instanceof ParseException) {
8387 {if (true) throw (ParseException)jjte000;}
8388 }
8389 {if (true) throw (Error)jjte000;}
8390 } finally {
8391 if (jjtc000) {
8392 jjtree.closeNodeScope(jjtn000, true);
8393 }
8394 }
8395 throw new Error("Missing return statement in function");
8396 }
8397
8398 final public ASTExceptionHandler ExceptionHandler() throws ParseException {
8399
8400 ASTExceptionHandler jjtn000 = new ASTExceptionHandler(this, JJTEXCEPTIONHANDLER);
8401 boolean jjtc000 = true;
8402 jjtree.openNodeScope(jjtn000);
8403 try {
8404 jj_consume_token(EXCEPTION);
8405 label_20:
8406 while (true) {
8407 if (jj_2_41(2)) {
8408 ;
8409 } else {
8410 break label_20;
8411 }
8412 jj_consume_token(WHEN);
8413 QualifiedName();
8414 label_21:
8415 while (true) {
8416 switch (jj_nt.kind) {
8417 case OR:
8418 ;
8419 break;
8420 default:
8421 jj_la1[115] = jj_gen;
8422 break label_21;
8423 }
8424 jj_consume_token(OR);
8425 QualifiedName();
8426 }
8427 jj_consume_token(THEN);
8428 label_22:
8429 while (true) {
8430 Statement();
8431 switch (jj_nt.kind) {
8432 case 5:
8433 case 16:
8434 case 17:
8435 case 21:
8436 case REPLACE:
8437 case DEFINER:
8438 case CURRENT_USER:
8439 case LANGUAGE:
8440 case INLINE:
8441 case ADD:
8442 case AGGREGATE:
8443 case ARRAY:
8444 case AT:
8445 case ATTRIBUTE:
8446 case AUTHID:
8447 case BEGIN:
8448 case BODY:
8449 case BULK:
8450 case BYTE:
8451 case CASCADE:
8452 case CASE:
8453 case CLOSE:
8454 case COALESCE:
8455 case COLLECT:
8456 case COLUMN:
8457 case COMMENT:
8458 case COMMIT:
8459 case CONSTRUCTOR:
8460 case CONTINUE:
8461 case CONVERT:
8462 case CURRENT:
8463 case CURSOR:
8464 case DATA:
8465 case DATE:
8466 case DAY:
8467 case DECLARE:
8468 case DELETE:
8469 case DISABLE:
8470 case EDITIONABLE:
8471 case ELEMENT:
8472 case ENABLE:
8473 case ESCAPE:
8474 case EXCEPT:
8475 case EXCEPTIONS:
8476 case EXECUTE:
8477 case EXIT:
8478 case EXTERNAL:
8479 case EXTENDS:
8480 case EXTRACT:
8481 case FALSE:
8482 case FETCH:
8483 case FINAL:
8484 case FOR:
8485 case FORALL:
8486 case FORCE:
8487 case FUNCTION:
8488 case GLOBAL:
8489 case GOTO:
8490 case HASH:
8491 case HEAP:
8492 case HOUR:
8493 case IF:
8494 case IMMEDIATE:
8495 case INDICES:
8496 case INDEXTYPE:
8497 case INDICATOR:
8498 case INSERT:
8499 case INSTANTIABLE:
8500 case INTERVAL:
8501 case INVALIDATE:
8502 case ISOLATION:
8503 case JAVA:
8504 case LEVEL:
8505 case LIMIT:
8506 case LOCK:
8507 case LOOP:
8508 case MAP:
8509 case MAX:
8510 case MEMBER:
8511 case MERGE:
8512 case MIN:
8513 case MINUTE:
8514 case MLSLABEL:
8515 case MODIFY:
8516 case MOD:
8517 case MONTH:
8518 case NATURAL:
8519 case NEW:
8520 case NEW_DOT:
8521 case NO:
8522 case NONEDITIONABLE:
8523 case NOT:
8524 case NULL:
8525 case NULLIF:
8526 case OBJECT:
8527 case OID:
8528 case OPAQUE:
8529 case OPEN:
8530 case OPERATOR:
8531 case ORGANIZATION:
8532 case OTHERS:
8533 case OVERRIDING:
8534 case PACKAGE:
8535 case PARTITION:
8536 case PIPE:
8537 case PRAGMA:
8538 case PRESERVE:
8539 case PRIVATE:
8540 case PROCEDURE:
8541 case RAISE:
8542 case RANGE:
8543 case RAW:
8544 case REAL:
8545 case RECORD:
8546 case REF:
8547 case RELEASE:
8548 case RELIES_ON:
8549 case RENAME:
8550 case RESULT:
8551 case RETURN:
8552 case RETURNING:
8553 case REVERSE:
8554 case ROLLBACK:
8555 case ROW:
8556 case ROWS:
8557 case ROWID:
8558 case ROWNUM:
8559 case SAVE:
8560 case SAVEPOINT:
8561 case SECOND:
8562 case SELECT:
8563 case SELF:
8564 case SET:
8565 case SPACE:
8566 case SQL:
8567 case SQLCODE:
8568 case SQLERRM:
8569 case STATIC:
8570 case SUBTYPE:
8571 case SUBSTITUTABLE:
8572 case SUCCESSFUL:
8573 case SYSDATE:
8574 case SYS_REFCURSOR:
8575 case TEMPORARY:
8576 case TIME:
8577 case TIMESTAMP:
8578 case TIMEZONE_REGION:
8579 case TIMEZONE_ABBR:
8580 case TIMEZONE_MINUTE:
8581 case TIMEZONE_HOUR:
8582 case TRANSACTION:
8583 case TRUE:
8584 case TYPE:
8585 case UNDER:
8586 case USING:
8587 case WHILE:
8588 case YES:
8589 case SHOW:
8590 case A:
8591 case UPDATE:
8592 case DOUBLE:
8593 case DEC:
8594 case PRECISION:
8595 case INT:
8596 case NUMERIC:
8597 case NCHAR:
8598 case NVARCHAR2:
8599 case STRING:
8600 case UROWID:
8601 case VARRAY:
8602 case VARYING:
8603 case BFILE:
8604 case BLOB:
8605 case CLOB:
8606 case NCLOB:
8607 case YEAR:
8608 case LOCAL:
8609 case WITH:
8610 case ZONE:
8611 case CHARACTER:
8612 case AFTER:
8613 case BEFORE:
8614 case OLD:
8615 case PARENT:
8616 case CC_IF:
8617 case CC_ERROR:
8618 case ANALYZE:
8619 case ASSOCIATE:
8620 case AUDIT:
8621 case COMPOUND:
8622 case DATABASE:
8623 case CALL:
8624 case DDL:
8625 case DISASSOCIATE:
8626 case EACH:
8627 case FOLLOWS:
8628 case LOGOFF:
8629 case LOGON:
8630 case NESTED:
8631 case NOAUDIT:
8632 case SCHEMA:
8633 case SERVERERROR:
8634 case SHUTDOWN:
8635 case STARTUP:
8636 case STATEMENT:
8637 case STATISTICS:
8638 case SUSPEND:
8639 case TRUNCATE:
8640 case WRAPPED:
8641 case LIBRARY:
8642 case NAME:
8643 case STRUCT:
8644 case CONTEXT:
8645 case PARAMETERS:
8646 case LENGTH:
8647 case TDO:
8648 case MAXLEN:
8649 case CHARSETID:
8650 case CHARSETFORM:
8651 case ACCEPT:
8652 case ACCESSIBLE:
8653 case COPY:
8654 case DEFINE:
8655 case DISCONNECT:
8656 case HOST:
8657 case PRINT:
8658 case QUIT:
8659 case REMARK:
8660 case UNDEFINE:
8661 case VARIABLE:
8662 case WHENEVER:
8663 case ATTACH:
8664 case CAST:
8665 case TREAT:
8666 case TRIM:
8667 case LEFT:
8668 case RIGHT:
8669 case BOTH:
8670 case EMPTY:
8671 case MULTISET:
8672 case SUBMULTISET:
8673 case LEADING:
8674 case TRAILING:
8675 case CHAR_CS:
8676 case NCHAR_CS:
8677 case DBTIMEZONE:
8678 case SESSIONTIMEZONE:
8679 case AUTHENTICATED:
8680 case LINK:
8681 case SHARED:
8682 case DIRECTORY:
8683 case USER:
8684 case IDENTIFIER:
8685 case UNSIGNED_NUMERIC_LITERAL:
8686 case CHARACTER_LITERAL:
8687 case STRING_LITERAL:
8688 case QUOTED_LITERAL:
8689 ;
8690 break;
8691 default:
8692 jj_la1[116] = jj_gen;
8693 break label_22;
8694 }
8695 }
8696 }
8697 switch (jj_nt.kind) {
8698 case WHEN:
8699 jj_consume_token(WHEN);
8700 jj_consume_token(OTHERS);
8701 jj_consume_token(THEN);
8702 label_23:
8703 while (true) {
8704 Statement();
8705 switch (jj_nt.kind) {
8706 case 5:
8707 case 16:
8708 case 17:
8709 case 21:
8710 case REPLACE:
8711 case DEFINER:
8712 case CURRENT_USER:
8713 case LANGUAGE:
8714 case INLINE:
8715 case ADD:
8716 case AGGREGATE:
8717 case ARRAY:
8718 case AT:
8719 case ATTRIBUTE:
8720 case AUTHID:
8721 case BEGIN:
8722 case BODY:
8723 case BULK:
8724 case BYTE:
8725 case CASCADE:
8726 case CASE:
8727 case CLOSE:
8728 case COALESCE:
8729 case COLLECT:
8730 case COLUMN:
8731 case COMMENT:
8732 case COMMIT:
8733 case CONSTRUCTOR:
8734 case CONTINUE:
8735 case CONVERT:
8736 case CURRENT:
8737 case CURSOR:
8738 case DATA:
8739 case DATE:
8740 case DAY:
8741 case DECLARE:
8742 case DELETE:
8743 case DISABLE:
8744 case EDITIONABLE:
8745 case ELEMENT:
8746 case ENABLE:
8747 case ESCAPE:
8748 case EXCEPT:
8749 case EXCEPTIONS:
8750 case EXECUTE:
8751 case EXIT:
8752 case EXTERNAL:
8753 case EXTENDS:
8754 case EXTRACT:
8755 case FALSE:
8756 case FETCH:
8757 case FINAL:
8758 case FOR:
8759 case FORALL:
8760 case FORCE:
8761 case FUNCTION:
8762 case GLOBAL:
8763 case GOTO:
8764 case HASH:
8765 case HEAP:
8766 case HOUR:
8767 case IF:
8768 case IMMEDIATE:
8769 case INDICES:
8770 case INDEXTYPE:
8771 case INDICATOR:
8772 case INSERT:
8773 case INSTANTIABLE:
8774 case INTERVAL:
8775 case INVALIDATE:
8776 case ISOLATION:
8777 case JAVA:
8778 case LEVEL:
8779 case LIMIT:
8780 case LOCK:
8781 case LOOP:
8782 case MAP:
8783 case MAX:
8784 case MEMBER:
8785 case MERGE:
8786 case MIN:
8787 case MINUTE:
8788 case MLSLABEL:
8789 case MODIFY:
8790 case MOD:
8791 case MONTH:
8792 case NATURAL:
8793 case NEW:
8794 case NEW_DOT:
8795 case NO:
8796 case NONEDITIONABLE:
8797 case NOT:
8798 case NULL:
8799 case NULLIF:
8800 case OBJECT:
8801 case OID:
8802 case OPAQUE:
8803 case OPEN:
8804 case OPERATOR:
8805 case ORGANIZATION:
8806 case OTHERS:
8807 case OVERRIDING:
8808 case PACKAGE:
8809 case PARTITION:
8810 case PIPE:
8811 case PRAGMA:
8812 case PRESERVE:
8813 case PRIVATE:
8814 case PROCEDURE:
8815 case RAISE:
8816 case RANGE:
8817 case RAW:
8818 case REAL:
8819 case RECORD:
8820 case REF:
8821 case RELEASE:
8822 case RELIES_ON:
8823 case RENAME:
8824 case RESULT:
8825 case RETURN:
8826 case RETURNING:
8827 case REVERSE:
8828 case ROLLBACK:
8829 case ROW:
8830 case ROWS:
8831 case ROWID:
8832 case ROWNUM:
8833 case SAVE:
8834 case SAVEPOINT:
8835 case SECOND:
8836 case SELECT:
8837 case SELF:
8838 case SET:
8839 case SPACE:
8840 case SQL:
8841 case SQLCODE:
8842 case SQLERRM:
8843 case STATIC:
8844 case SUBTYPE:
8845 case SUBSTITUTABLE:
8846 case SUCCESSFUL:
8847 case SYSDATE:
8848 case SYS_REFCURSOR:
8849 case TEMPORARY:
8850 case TIME:
8851 case TIMESTAMP:
8852 case TIMEZONE_REGION:
8853 case TIMEZONE_ABBR:
8854 case TIMEZONE_MINUTE:
8855 case TIMEZONE_HOUR:
8856 case TRANSACTION:
8857 case TRUE:
8858 case TYPE:
8859 case UNDER:
8860 case USING:
8861 case WHILE:
8862 case YES:
8863 case SHOW:
8864 case A:
8865 case UPDATE:
8866 case DOUBLE:
8867 case DEC:
8868 case PRECISION:
8869 case INT:
8870 case NUMERIC:
8871 case NCHAR:
8872 case NVARCHAR2:
8873 case STRING:
8874 case UROWID:
8875 case VARRAY:
8876 case VARYING:
8877 case BFILE:
8878 case BLOB:
8879 case CLOB:
8880 case NCLOB:
8881 case YEAR:
8882 case LOCAL:
8883 case WITH:
8884 case ZONE:
8885 case CHARACTER:
8886 case AFTER:
8887 case BEFORE:
8888 case OLD:
8889 case PARENT:
8890 case CC_IF:
8891 case CC_ERROR:
8892 case ANALYZE:
8893 case ASSOCIATE:
8894 case AUDIT:
8895 case COMPOUND:
8896 case DATABASE:
8897 case CALL:
8898 case DDL:
8899 case DISASSOCIATE:
8900 case EACH:
8901 case FOLLOWS:
8902 case LOGOFF:
8903 case LOGON:
8904 case NESTED:
8905 case NOAUDIT:
8906 case SCHEMA:
8907 case SERVERERROR:
8908 case SHUTDOWN:
8909 case STARTUP:
8910 case STATEMENT:
8911 case STATISTICS:
8912 case SUSPEND:
8913 case TRUNCATE:
8914 case WRAPPED:
8915 case LIBRARY:
8916 case NAME:
8917 case STRUCT:
8918 case CONTEXT:
8919 case PARAMETERS:
8920 case LENGTH:
8921 case TDO:
8922 case MAXLEN:
8923 case CHARSETID:
8924 case CHARSETFORM:
8925 case ACCEPT:
8926 case ACCESSIBLE:
8927 case COPY:
8928 case DEFINE:
8929 case DISCONNECT:
8930 case HOST:
8931 case PRINT:
8932 case QUIT:
8933 case REMARK:
8934 case UNDEFINE:
8935 case VARIABLE:
8936 case WHENEVER:
8937 case ATTACH:
8938 case CAST:
8939 case TREAT:
8940 case TRIM:
8941 case LEFT:
8942 case RIGHT:
8943 case BOTH:
8944 case EMPTY:
8945 case MULTISET:
8946 case SUBMULTISET:
8947 case LEADING:
8948 case TRAILING:
8949 case CHAR_CS:
8950 case NCHAR_CS:
8951 case DBTIMEZONE:
8952 case SESSIONTIMEZONE:
8953 case AUTHENTICATED:
8954 case LINK:
8955 case SHARED:
8956 case DIRECTORY:
8957 case USER:
8958 case IDENTIFIER:
8959 case UNSIGNED_NUMERIC_LITERAL:
8960 case CHARACTER_LITERAL:
8961 case STRING_LITERAL:
8962 case QUOTED_LITERAL:
8963 ;
8964 break;
8965 default:
8966 jj_la1[117] = jj_gen;
8967 break label_23;
8968 }
8969 }
8970 break;
8971 default:
8972 jj_la1[118] = jj_gen;
8973 ;
8974 }
8975 jjtree.closeNodeScope(jjtn000, true);
8976 jjtc000 = false;
8977 {if (true) return jjtn000 ;}
8978 } catch (Throwable jjte000) {
8979 if (jjtc000) {
8980 jjtree.clearNodeScope(jjtn000);
8981 jjtc000 = false;
8982 } else {
8983 jjtree.popNode();
8984 }
8985 if (jjte000 instanceof RuntimeException) {
8986 {if (true) throw (RuntimeException)jjte000;}
8987 }
8988 if (jjte000 instanceof ParseException) {
8989 {if (true) throw (ParseException)jjte000;}
8990 }
8991 {if (true) throw (Error)jjte000;}
8992 } finally {
8993 if (jjtc000) {
8994 jjtree.closeNodeScope(jjtn000, true);
8995 }
8996 }
8997 throw new Error("Missing return statement in function");
8998 }
8999
9000 final public void Skip2NextTerminator(String initiator,String terminator) throws ParseException {
9001
9002 ASTSkip2NextTerminator jjtn000 = new ASTSkip2NextTerminator(this, JJTSKIP2NEXTTERMINATOR);
9003 boolean jjtc000 = true;
9004 jjtree.openNodeScope(jjtn000);Token t = getToken(1);
9005 int count = (initiator == null) ? 0 : 1;
9006 if(t.image.equals(initiator)) count++;
9007 while (count > 0 || !t.image.equals(terminator))
9008 {
9009 t = getNextToken();
9010 t = getToken(1);
9011 if(t.image.equals(initiator)) count++;
9012 if(t.image.equals(terminator)) count--;
9013 if(null != t.specialToken || t.kind == EOF)
9014 return;
9015 }
9016 try {
9017 jjtree.closeNodeScope(jjtn000, true);
9018 jjtc000 = false;
9019 {if (true) return;}
9020 } finally {
9021 if (jjtc000) {
9022 jjtree.closeNodeScope(jjtn000, true);
9023 }
9024 }
9025 }
9026
9027
9028
9029
9030 final public void Skip2NextOccurrence(String target) throws ParseException {
9031
9032 ASTSkip2NextOccurrence jjtn000 = new ASTSkip2NextOccurrence(this, JJTSKIP2NEXTOCCURRENCE);
9033 boolean jjtc000 = true;
9034 jjtree.openNodeScope(jjtn000);Token nextToken = getToken(1);
9035 while (!nextToken.image.equals(target)
9036 && (null == nextToken.specialToken || !nextToken.specialToken.image.equals(target) )
9037 && nextToken.kind!=EOF
9038 )
9039 {
9040 nextToken = getNextToken();
9041 nextToken = getToken(1);
9042 }
9043 try {
9044 jjtree.closeNodeScope(jjtn000, true);
9045 jjtc000 = false;
9046 {if (true) return;}
9047 } finally {
9048 if (jjtc000) {
9049 jjtree.closeNodeScope(jjtn000, true);
9050 }
9051 }
9052 }
9053
9054
9055
9056
9057 final public void SkipPastNextOccurrence(String target) throws ParseException {
9058
9059 ASTSkipPastNextOccurrence jjtn000 = new ASTSkipPastNextOccurrence(this, JJTSKIPPASTNEXTOCCURRENCE);
9060 boolean jjtc000 = true;
9061 jjtree.openNodeScope(jjtn000);Token t = null;
9062 Skip2NextOccurrence(target) ;
9063 t = getNextToken();
9064 try {
9065 jjtree.closeNodeScope(jjtn000, true);
9066 jjtc000 = false;
9067 {if (true) return;}
9068 } finally {
9069 if (jjtc000) {
9070 jjtree.closeNodeScope(jjtn000, true);
9071 }
9072 }
9073 }
9074
9075
9076
9077
9078 final public void Skip2NextTokenOccurrence(int target) throws ParseException {
9079
9080 ASTSkip2NextTokenOccurrence jjtn000 = new ASTSkip2NextTokenOccurrence(this, JJTSKIP2NEXTTOKENOCCURRENCE);
9081 boolean jjtc000 = true;
9082 jjtree.openNodeScope(jjtn000);Token nextToken = getToken(1);
9083 Token specToken = null ;
9084 while (nextToken.kind!=target
9085 && (null == nextToken.specialToken || nextToken.specialToken.kind!=target )
9086 && nextToken.kind!=EOF
9087 )
9088 {
9089
9090
9091
9092
9093
9094
9095
9096
9097
9098
9099
9100
9101
9102
9103 specToken = nextToken.specialToken;
9104 if (null!= specToken)
9105 {
9106
9107 while (specToken != null && specToken.kind != target)
9108 {
9109 specToken = specToken.specialToken;
9110 }
9111
9112
9113 if (null != specToken && specToken.kind == target)
9114 {
9115 break;
9116 }
9117 }
9118
9119 nextToken = getNextToken();
9120 nextToken = getToken(1);
9121 }
9122 try {
9123 jjtree.closeNodeScope(jjtn000, true);
9124 jjtc000 = false;
9125 {if (true) return;}
9126 } finally {
9127 if (jjtc000) {
9128 jjtree.closeNodeScope(jjtn000, true);
9129 }
9130 }
9131 }
9132
9133
9134
9135
9136 final public void SkipPastNextTokenOccurrence(int target) throws ParseException {
9137
9138 ASTSkipPastNextTokenOccurrence jjtn000 = new ASTSkipPastNextTokenOccurrence(this, JJTSKIPPASTNEXTTOKENOCCURRENCE);
9139 boolean jjtc000 = true;
9140 jjtree.openNodeScope(jjtn000);Token t = null;
9141 Skip2NextTokenOccurrence(target) ;
9142 t = getNextToken();
9143 try {
9144 jjtree.closeNodeScope(jjtn000, true);
9145 jjtc000 = false;
9146 {if (true) return;}
9147 } finally {
9148 if (jjtc000) {
9149 jjtree.closeNodeScope(jjtn000, true);
9150 }
9151 }
9152 }
9153
9154
9155
9156
9157 final public ASTRead2NextOccurrence Read2NextOccurrence(String target) throws ParseException {
9158
9159 ASTRead2NextOccurrence jjtn000 = new ASTRead2NextOccurrence(this, JJTREAD2NEXTOCCURRENCE);
9160 boolean jjtc000 = true;
9161 jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
9162 Token nextToken = getToken(1);
9163 while (!nextToken.image.equals(target)
9164 && nextToken.kind!=EOF
9165 )
9166 {
9167 nextToken = getNextToken();
9168 sb.append(nextToken.image);
9169 nextToken = getToken(1);
9170 }
9171 try {
9172 jjtree.closeNodeScope(jjtn000, true);
9173 jjtc000 = false;
9174 jjtn000.setImage(sb.toString()) ; jjtn000.value = sb.toString(); {if (true) return jjtn000 ;}
9175 } finally {
9176 if (jjtc000) {
9177 jjtree.closeNodeScope(jjtn000, true);
9178 }
9179 }
9180 throw new Error("Missing return statement in function");
9181 }
9182
9183
9184
9185
9186 final public ASTReadPastNextOccurrence ReadPastNextOccurrence(String target) throws ParseException {
9187
9188 ASTReadPastNextOccurrence jjtn000 = new ASTReadPastNextOccurrence(this, JJTREADPASTNEXTOCCURRENCE);
9189 boolean jjtc000 = true;
9190 jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
9191 Token t = null;
9192 sb.append(Read2NextOccurrence(target)) ;
9193 t = getNextToken();
9194 sb.append(t.image);
9195 try {
9196 jjtree.closeNodeScope(jjtn000, true);
9197 jjtc000 = false;
9198 jjtn000.setImage(sb.toString()) ; jjtn000.value = sb.toString(); {if (true) return jjtn000 ;}
9199 } finally {
9200 if (jjtc000) {
9201 jjtree.closeNodeScope(jjtn000, true);
9202 }
9203 }
9204 throw new Error("Missing return statement in function");
9205 }
9206
9207
9208
9209
9210 final public ASTSqlStatement SqlStatement(String initiator, String terminator) throws ParseException {
9211
9212 ASTSqlStatement jjtn000 = new ASTSqlStatement(this, JJTSQLSTATEMENT);
9213 boolean jjtc000 = true;
9214 jjtree.openNodeScope(jjtn000);
9215 try {
9216 switch (jj_nt.kind) {
9217 case SELECT:
9218 jj_consume_token(SELECT);
9219 break;
9220 case UPDATE:
9221 jj_consume_token(UPDATE);
9222 break;
9223 case INSERT:
9224 jj_consume_token(INSERT);
9225 break;
9226 case DELETE:
9227 jj_consume_token(DELETE);
9228 break;
9229 case COMMIT:
9230 jj_consume_token(COMMIT);
9231 break;
9232 case ROLLBACK:
9233 jj_consume_token(ROLLBACK);
9234 break;
9235 case SAVEPOINT:
9236 jj_consume_token(SAVEPOINT);
9237 break;
9238 case EXECUTE:
9239 jj_consume_token(EXECUTE);
9240 break;
9241 case SET:
9242 jj_consume_token(SET);
9243 jj_consume_token(TRANSACTION);
9244 break;
9245 case LOCK:
9246 jj_consume_token(LOCK);
9247 jj_consume_token(TABLE);
9248 break;
9249 case MERGE:
9250 jj_consume_token(MERGE);
9251 break;
9252 case WITH:
9253 jj_consume_token(WITH);
9254 break;
9255 default:
9256 jj_la1[119] = jj_gen;
9257 jj_consume_token(-1);
9258 throw new ParseException();
9259 }
9260 Skip2NextTerminator(initiator,terminator);
9261 jjtree.closeNodeScope(jjtn000, true);
9262 jjtc000 = false;
9263 {if (true) return jjtn000 ;}
9264 } catch (Throwable jjte000) {
9265 if (jjtc000) {
9266 jjtree.clearNodeScope(jjtn000);
9267 jjtc000 = false;
9268 } else {
9269 jjtree.popNode();
9270 }
9271 if (jjte000 instanceof RuntimeException) {
9272 {if (true) throw (RuntimeException)jjte000;}
9273 }
9274 if (jjte000 instanceof ParseException) {
9275 {if (true) throw (ParseException)jjte000;}
9276 }
9277 {if (true) throw (Error)jjte000;}
9278 } finally {
9279 if (jjtc000) {
9280 jjtree.closeNodeScope(jjtn000, true);
9281 }
9282 }
9283 throw new Error("Missing return statement in function");
9284 }
9285
9286
9287
9288
9289
9290
9291
9292
9293
9294
9295
9296
9297
9298
9299
9300
9301
9302
9303
9304
9305
9306
9307
9308
9309
9310
9311
9312
9313
9314
9315
9316
9317
9318
9319
9320
9321
9322 final public void WrappedObject() throws ParseException {
9323
9324 ASTWrappedObject jjtn000 = new ASTWrappedObject(this, JJTWRAPPEDOBJECT);
9325 boolean jjtc000 = true;
9326 jjtree.openNodeScope(jjtn000);
9327 try {
9328 jj_consume_token(WRAPPED);
9329 jjtree.closeNodeScope(jjtn000, true);
9330 jjtc000 = false;
9331 Token nextToken;
9332
9333 nextToken = getToken(1);
9334 while (
9335 null != nextToken && nextToken.kind!=EOF
9336 )
9337 {
9338 nextToken = getNextToken();
9339
9340
9341 nextToken = getToken(1);
9342 }
9343 {if (true) return;}
9344 } finally {
9345 if (jjtc000) {
9346 jjtree.closeNodeScope(jjtn000, true);
9347 }
9348 }
9349 }
9350
9351
9352
9353
9354
9355
9356
9357
9358 final public ASTUnlabelledStatement UnlabelledStatement() throws ParseException {
9359
9360 ASTUnlabelledStatement jjtn000 = new ASTUnlabelledStatement(this, JJTUNLABELLEDSTATEMENT);
9361 boolean jjtc000 = true;
9362 jjtree.openNodeScope(jjtn000);
9363 try {
9364 if (jj_2_42(2147483647)) {
9365 SqlStatement(null,";");
9366 switch (jj_nt.kind) {
9367 case 4:
9368 jj_consume_token(4);
9369 break;
9370 default:
9371 jj_la1[120] = jj_gen;
9372 ;
9373 }
9374 } else if (jj_2_43(3)) {
9375 ContinueStatement();
9376 jj_consume_token(4);
9377 } else {
9378 switch (jj_nt.kind) {
9379 case CASE:
9380 CaseStatement();
9381 jj_consume_token(4);
9382 break;
9383 case IF:
9384 IfStatement();
9385 jj_consume_token(4);
9386 break;
9387 case FOR:
9388 ForStatement();
9389 jj_consume_token(4);
9390 break;
9391 case FORALL:
9392 ForAllStatement();
9393 jj_consume_token(4);
9394 break;
9395 case LOOP:
9396 LoopStatement();
9397 jj_consume_token(4);
9398 break;
9399 case WHILE:
9400 WhileStatement();
9401 jj_consume_token(4);
9402 break;
9403 case GOTO:
9404 GotoStatement();
9405 jj_consume_token(4);
9406 break;
9407 case RETURN:
9408 ReturnStatement();
9409 jj_consume_token(4);
9410 break;
9411 case EXIT:
9412 ExitStatement();
9413 jj_consume_token(4);
9414 break;
9415 case RAISE:
9416 RaiseStatement();
9417 jj_consume_token(4);
9418 break;
9419 case CLOSE:
9420 CloseStatement();
9421 jj_consume_token(4);
9422 break;
9423 case OPEN:
9424 OpenStatement();
9425 jj_consume_token(4);
9426 break;
9427 case FETCH:
9428 FetchStatement();
9429 jj_consume_token(4);
9430 break;
9431 case BEGIN:
9432 case DECLARE:
9433 Block();
9434 jj_consume_token(4);
9435 break;
9436 case EXECUTE:
9437 EmbeddedSqlStatement();
9438 jj_consume_token(4);
9439 break;
9440 case PIPE:
9441 PipelineStatement();
9442 jj_consume_token(4);
9443 break;
9444 case CC_IF:
9445 case CC_ERROR:
9446 ConditionalCompilationStatement();
9447 break;
9448 case PRAGMA:
9449 InlinePragma();
9450 jj_consume_token(4);
9451 break;
9452 case 5:
9453 case 16:
9454 case 17:
9455 case REPLACE:
9456 case DEFINER:
9457 case CURRENT_USER:
9458 case LANGUAGE:
9459 case INLINE:
9460 case ADD:
9461 case AGGREGATE:
9462 case ARRAY:
9463 case AT:
9464 case ATTRIBUTE:
9465 case AUTHID:
9466 case BODY:
9467 case BULK:
9468 case BYTE:
9469 case CASCADE:
9470 case COALESCE:
9471 case COLLECT:
9472 case COLUMN:
9473 case COMMENT:
9474 case COMMIT:
9475 case CONSTRUCTOR:
9476 case CONTINUE:
9477 case CONVERT:
9478 case CURRENT:
9479 case CURSOR:
9480 case DATA:
9481 case DATE:
9482 case DAY:
9483 case DISABLE:
9484 case EDITIONABLE:
9485 case ELEMENT:
9486 case ENABLE:
9487 case ESCAPE:
9488 case EXCEPT:
9489 case EXCEPTIONS:
9490 case EXTERNAL:
9491 case EXTENDS:
9492 case EXTRACT:
9493 case FALSE:
9494 case FINAL:
9495 case FORCE:
9496 case FUNCTION:
9497 case GLOBAL:
9498 case HASH:
9499 case HEAP:
9500 case HOUR:
9501 case IMMEDIATE:
9502 case INDICES:
9503 case INDEXTYPE:
9504 case INDICATOR:
9505 case INSTANTIABLE:
9506 case INTERVAL:
9507 case INVALIDATE:
9508 case ISOLATION:
9509 case JAVA:
9510 case LEVEL:
9511 case LIMIT:
9512 case MAP:
9513 case MAX:
9514 case MEMBER:
9515 case MERGE:
9516 case MIN:
9517 case MINUTE:
9518 case MLSLABEL:
9519 case MODIFY:
9520 case MOD:
9521 case MONTH:
9522 case NATURAL:
9523 case NEW:
9524 case NEW_DOT:
9525 case NO:
9526 case NONEDITIONABLE:
9527 case NOT:
9528 case NULL:
9529 case NULLIF:
9530 case OBJECT:
9531 case OID:
9532 case OPAQUE:
9533 case OPERATOR:
9534 case ORGANIZATION:
9535 case OTHERS:
9536 case OVERRIDING:
9537 case PACKAGE:
9538 case PARTITION:
9539 case PRESERVE:
9540 case PRIVATE:
9541 case PROCEDURE:
9542 case RANGE:
9543 case RAW:
9544 case REAL:
9545 case RECORD:
9546 case REF:
9547 case RELEASE:
9548 case RELIES_ON:
9549 case RENAME:
9550 case RESULT:
9551 case RETURNING:
9552 case REVERSE:
9553 case ROLLBACK:
9554 case ROW:
9555 case ROWS:
9556 case ROWID:
9557 case ROWNUM:
9558 case SAVE:
9559 case SAVEPOINT:
9560 case SECOND:
9561 case SELECT:
9562 case SELF:
9563 case SET:
9564 case SPACE:
9565 case SQL:
9566 case SQLCODE:
9567 case SQLERRM:
9568 case STATIC:
9569 case SUBTYPE:
9570 case SUBSTITUTABLE:
9571 case SUCCESSFUL:
9572 case SYSDATE:
9573 case SYS_REFCURSOR:
9574 case TEMPORARY:
9575 case TIME:
9576 case TIMESTAMP:
9577 case TIMEZONE_REGION:
9578 case TIMEZONE_ABBR:
9579 case TIMEZONE_MINUTE:
9580 case TIMEZONE_HOUR:
9581 case TRANSACTION:
9582 case TRUE:
9583 case TYPE:
9584 case UNDER:
9585 case USING:
9586 case YES:
9587 case SHOW:
9588 case A:
9589 case DOUBLE:
9590 case DEC:
9591 case PRECISION:
9592 case INT:
9593 case NUMERIC:
9594 case NCHAR:
9595 case NVARCHAR2:
9596 case STRING:
9597 case UROWID:
9598 case VARRAY:
9599 case VARYING:
9600 case BFILE:
9601 case BLOB:
9602 case CLOB:
9603 case NCLOB:
9604 case YEAR:
9605 case LOCAL:
9606 case WITH:
9607 case ZONE:
9608 case CHARACTER:
9609 case AFTER:
9610 case BEFORE:
9611 case OLD:
9612 case PARENT:
9613 case ANALYZE:
9614 case ASSOCIATE:
9615 case AUDIT:
9616 case COMPOUND:
9617 case DATABASE:
9618 case CALL:
9619 case DDL:
9620 case DISASSOCIATE:
9621 case EACH:
9622 case FOLLOWS:
9623 case LOGOFF:
9624 case LOGON:
9625 case NESTED:
9626 case NOAUDIT:
9627 case SCHEMA:
9628 case SERVERERROR:
9629 case SHUTDOWN:
9630 case STARTUP:
9631 case STATEMENT:
9632 case STATISTICS:
9633 case SUSPEND:
9634 case TRUNCATE:
9635 case WRAPPED:
9636 case LIBRARY:
9637 case NAME:
9638 case STRUCT:
9639 case CONTEXT:
9640 case PARAMETERS:
9641 case LENGTH:
9642 case TDO:
9643 case MAXLEN:
9644 case CHARSETID:
9645 case CHARSETFORM:
9646 case ACCEPT:
9647 case ACCESSIBLE:
9648 case COPY:
9649 case DEFINE:
9650 case DISCONNECT:
9651 case HOST:
9652 case PRINT:
9653 case QUIT:
9654 case REMARK:
9655 case UNDEFINE:
9656 case VARIABLE:
9657 case WHENEVER:
9658 case ATTACH:
9659 case CAST:
9660 case TREAT:
9661 case TRIM:
9662 case LEFT:
9663 case RIGHT:
9664 case BOTH:
9665 case EMPTY:
9666 case MULTISET:
9667 case SUBMULTISET:
9668 case LEADING:
9669 case TRAILING:
9670 case CHAR_CS:
9671 case NCHAR_CS:
9672 case DBTIMEZONE:
9673 case SESSIONTIMEZONE:
9674 case AUTHENTICATED:
9675 case LINK:
9676 case SHARED:
9677 case DIRECTORY:
9678 case USER:
9679 case IDENTIFIER:
9680 case UNSIGNED_NUMERIC_LITERAL:
9681 case CHARACTER_LITERAL:
9682 case STRING_LITERAL:
9683 case QUOTED_LITERAL:
9684 Expression();
9685 jj_consume_token(4);
9686 break;
9687 default:
9688 jj_la1[121] = jj_gen;
9689 jj_consume_token(-1);
9690 throw new ParseException();
9691 }
9692 }
9693 jjtree.closeNodeScope(jjtn000, true);
9694 jjtc000 = false;
9695 {if (true) return jjtn000 ;}
9696 } catch (Throwable jjte000) {
9697 if (jjtc000) {
9698 jjtree.clearNodeScope(jjtn000);
9699 jjtc000 = false;
9700 } else {
9701 jjtree.popNode();
9702 }
9703 if (jjte000 instanceof RuntimeException) {
9704 {if (true) throw (RuntimeException)jjte000;}
9705 }
9706 if (jjte000 instanceof ParseException) {
9707 {if (true) throw (ParseException)jjte000;}
9708 }
9709 {if (true) throw (Error)jjte000;}
9710 } finally {
9711 if (jjtc000) {
9712 jjtree.closeNodeScope(jjtn000, true);
9713 }
9714 }
9715 throw new Error("Missing return statement in function");
9716 }
9717
9718 final public ASTStatement Statement() throws ParseException {
9719
9720 ASTStatement jjtn000 = new ASTStatement(this, JJTSTATEMENT);
9721 boolean jjtc000 = true;
9722 jjtree.openNodeScope(jjtn000);
9723 try {
9724 switch (jj_nt.kind) {
9725 case 21:
9726 LabelledStatement();
9727 break;
9728 case 5:
9729 case 16:
9730 case 17:
9731 case REPLACE:
9732 case DEFINER:
9733 case CURRENT_USER:
9734 case LANGUAGE:
9735 case INLINE:
9736 case ADD:
9737 case AGGREGATE:
9738 case ARRAY:
9739 case AT:
9740 case ATTRIBUTE:
9741 case AUTHID:
9742 case BEGIN:
9743 case BODY:
9744 case BULK:
9745 case BYTE:
9746 case CASCADE:
9747 case CASE:
9748 case CLOSE:
9749 case COALESCE:
9750 case COLLECT:
9751 case COLUMN:
9752 case COMMENT:
9753 case COMMIT:
9754 case CONSTRUCTOR:
9755 case CONTINUE:
9756 case CONVERT:
9757 case CURRENT:
9758 case CURSOR:
9759 case DATA:
9760 case DATE:
9761 case DAY:
9762 case DECLARE:
9763 case DELETE:
9764 case DISABLE:
9765 case EDITIONABLE:
9766 case ELEMENT:
9767 case ENABLE:
9768 case ESCAPE:
9769 case EXCEPT:
9770 case EXCEPTIONS:
9771 case EXECUTE:
9772 case EXIT:
9773 case EXTERNAL:
9774 case EXTENDS:
9775 case EXTRACT:
9776 case FALSE:
9777 case FETCH:
9778 case FINAL:
9779 case FOR:
9780 case FORALL:
9781 case FORCE:
9782 case FUNCTION:
9783 case GLOBAL:
9784 case GOTO:
9785 case HASH:
9786 case HEAP:
9787 case HOUR:
9788 case IF:
9789 case IMMEDIATE:
9790 case INDICES:
9791 case INDEXTYPE:
9792 case INDICATOR:
9793 case INSERT:
9794 case INSTANTIABLE:
9795 case INTERVAL:
9796 case INVALIDATE:
9797 case ISOLATION:
9798 case JAVA:
9799 case LEVEL:
9800 case LIMIT:
9801 case LOCK:
9802 case LOOP:
9803 case MAP:
9804 case MAX:
9805 case MEMBER:
9806 case MERGE:
9807 case MIN:
9808 case MINUTE:
9809 case MLSLABEL:
9810 case MODIFY:
9811 case MOD:
9812 case MONTH:
9813 case NATURAL:
9814 case NEW:
9815 case NEW_DOT:
9816 case NO:
9817 case NONEDITIONABLE:
9818 case NOT:
9819 case NULL:
9820 case NULLIF:
9821 case OBJECT:
9822 case OID:
9823 case OPAQUE:
9824 case OPEN:
9825 case OPERATOR:
9826 case ORGANIZATION:
9827 case OTHERS:
9828 case OVERRIDING:
9829 case PACKAGE:
9830 case PARTITION:
9831 case PIPE:
9832 case PRAGMA:
9833 case PRESERVE:
9834 case PRIVATE:
9835 case PROCEDURE:
9836 case RAISE:
9837 case RANGE:
9838 case RAW:
9839 case REAL:
9840 case RECORD:
9841 case REF:
9842 case RELEASE:
9843 case RELIES_ON:
9844 case RENAME:
9845 case RESULT:
9846 case RETURN:
9847 case RETURNING:
9848 case REVERSE:
9849 case ROLLBACK:
9850 case ROW:
9851 case ROWS:
9852 case ROWID:
9853 case ROWNUM:
9854 case SAVE:
9855 case SAVEPOINT:
9856 case SECOND:
9857 case SELECT:
9858 case SELF:
9859 case SET:
9860 case SPACE:
9861 case SQL:
9862 case SQLCODE:
9863 case SQLERRM:
9864 case STATIC:
9865 case SUBTYPE:
9866 case SUBSTITUTABLE:
9867 case SUCCESSFUL:
9868 case SYSDATE:
9869 case SYS_REFCURSOR:
9870 case TEMPORARY:
9871 case TIME:
9872 case TIMESTAMP:
9873 case TIMEZONE_REGION:
9874 case TIMEZONE_ABBR:
9875 case TIMEZONE_MINUTE:
9876 case TIMEZONE_HOUR:
9877 case TRANSACTION:
9878 case TRUE:
9879 case TYPE:
9880 case UNDER:
9881 case USING:
9882 case WHILE:
9883 case YES:
9884 case SHOW:
9885 case A:
9886 case UPDATE:
9887 case DOUBLE:
9888 case DEC:
9889 case PRECISION:
9890 case INT:
9891 case NUMERIC:
9892 case NCHAR:
9893 case NVARCHAR2:
9894 case STRING:
9895 case UROWID:
9896 case VARRAY:
9897 case VARYING:
9898 case BFILE:
9899 case BLOB:
9900 case CLOB:
9901 case NCLOB:
9902 case YEAR:
9903 case LOCAL:
9904 case WITH:
9905 case ZONE:
9906 case CHARACTER:
9907 case AFTER:
9908 case BEFORE:
9909 case OLD:
9910 case PARENT:
9911 case CC_IF:
9912 case CC_ERROR:
9913 case ANALYZE:
9914 case ASSOCIATE:
9915 case AUDIT:
9916 case COMPOUND:
9917 case DATABASE:
9918 case CALL:
9919 case DDL:
9920 case DISASSOCIATE:
9921 case EACH:
9922 case FOLLOWS:
9923 case LOGOFF:
9924 case LOGON:
9925 case NESTED:
9926 case NOAUDIT:
9927 case SCHEMA:
9928 case SERVERERROR:
9929 case SHUTDOWN:
9930 case STARTUP:
9931 case STATEMENT:
9932 case STATISTICS:
9933 case SUSPEND:
9934 case TRUNCATE:
9935 case WRAPPED:
9936 case LIBRARY:
9937 case NAME:
9938 case STRUCT:
9939 case CONTEXT:
9940 case PARAMETERS:
9941 case LENGTH:
9942 case TDO:
9943 case MAXLEN:
9944 case CHARSETID:
9945 case CHARSETFORM:
9946 case ACCEPT:
9947 case ACCESSIBLE:
9948 case COPY:
9949 case DEFINE:
9950 case DISCONNECT:
9951 case HOST:
9952 case PRINT:
9953 case QUIT:
9954 case REMARK:
9955 case UNDEFINE:
9956 case VARIABLE:
9957 case WHENEVER:
9958 case ATTACH:
9959 case CAST:
9960 case TREAT:
9961 case TRIM:
9962 case LEFT:
9963 case RIGHT:
9964 case BOTH:
9965 case EMPTY:
9966 case MULTISET:
9967 case SUBMULTISET:
9968 case LEADING:
9969 case TRAILING:
9970 case CHAR_CS:
9971 case NCHAR_CS:
9972 case DBTIMEZONE:
9973 case SESSIONTIMEZONE:
9974 case AUTHENTICATED:
9975 case LINK:
9976 case SHARED:
9977 case DIRECTORY:
9978 case USER:
9979 case IDENTIFIER:
9980 case UNSIGNED_NUMERIC_LITERAL:
9981 case CHARACTER_LITERAL:
9982 case STRING_LITERAL:
9983 case QUOTED_LITERAL:
9984 UnlabelledStatement();
9985 break;
9986 default:
9987 jj_la1[122] = jj_gen;
9988 jj_consume_token(-1);
9989 throw new ParseException();
9990 }
9991 jjtree.closeNodeScope(jjtn000, true);
9992 jjtc000 = false;
9993 {if (true) return jjtn000 ;}
9994 } catch (Throwable jjte000) {
9995 if (jjtc000) {
9996 jjtree.clearNodeScope(jjtn000);
9997 jjtc000 = false;
9998 } else {
9999 jjtree.popNode();
10000 }
10001 if (jjte000 instanceof RuntimeException) {
10002 {if (true) throw (RuntimeException)jjte000;}
10003 }
10004 if (jjte000 instanceof ParseException) {
10005 {if (true) throw (ParseException)jjte000;}
10006 }
10007 {if (true) throw (Error)jjte000;}
10008 } finally {
10009 if (jjtc000) {
10010 jjtree.closeNodeScope(jjtn000, true);
10011 }
10012 }
10013 throw new Error("Missing return statement in function");
10014 }
10015
10016
10017
10018
10019
10020 final public ASTLabelledStatement LabelledStatement() throws ParseException {
10021
10022 ASTLabelledStatement jjtn000 = new ASTLabelledStatement(this, JJTLABELLEDSTATEMENT);
10023 boolean jjtc000 = true;
10024 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
10025 try {
10026 label_24:
10027 while (true) {
10028 simpleNode = Label();
10029 switch (jj_nt.kind) {
10030 case 21:
10031 ;
10032 break;
10033 default:
10034 jj_la1[123] = jj_gen;
10035 break label_24;
10036 }
10037 }
10038 UnlabelledStatement();
10039 jjtree.closeNodeScope(jjtn000, true);
10040 jjtc000 = false;
10041 jjtn000.setImage( simpleNode.getImage() ) ;
10042 {if (true) return jjtn000 ;}
10043 } catch (Throwable jjte000) {
10044 if (jjtc000) {
10045 jjtree.clearNodeScope(jjtn000);
10046 jjtc000 = false;
10047 } else {
10048 jjtree.popNode();
10049 }
10050 if (jjte000 instanceof RuntimeException) {
10051 {if (true) throw (RuntimeException)jjte000;}
10052 }
10053 if (jjte000 instanceof ParseException) {
10054 {if (true) throw (ParseException)jjte000;}
10055 }
10056 {if (true) throw (Error)jjte000;}
10057 } finally {
10058 if (jjtc000) {
10059 jjtree.closeNodeScope(jjtn000, true);
10060 }
10061 }
10062 throw new Error("Missing return statement in function");
10063 }
10064
10065 final public ASTCaseStatement CaseStatement() throws ParseException {
10066
10067 ASTCaseStatement jjtn000 = new ASTCaseStatement(this, JJTCASESTATEMENT);
10068 boolean jjtc000 = true;
10069 jjtree.openNodeScope(jjtn000);
10070 try {
10071 jj_consume_token(CASE);
10072 switch (jj_nt.kind) {
10073 case 5:
10074 case 16:
10075 case 17:
10076 case REPLACE:
10077 case DEFINER:
10078 case CURRENT_USER:
10079 case LANGUAGE:
10080 case INLINE:
10081 case ADD:
10082 case AGGREGATE:
10083 case ARRAY:
10084 case AT:
10085 case ATTRIBUTE:
10086 case AUTHID:
10087 case BODY:
10088 case BULK:
10089 case BYTE:
10090 case CASCADE:
10091 case CASE:
10092 case CLOSE:
10093 case COALESCE:
10094 case COLLECT:
10095 case COLUMN:
10096 case COMMENT:
10097 case COMMIT:
10098 case CONSTRUCTOR:
10099 case CONTINUE:
10100 case CONVERT:
10101 case CURRENT:
10102 case CURSOR:
10103 case DATA:
10104 case DATE:
10105 case DAY:
10106 case DISABLE:
10107 case EDITIONABLE:
10108 case ELEMENT:
10109 case ENABLE:
10110 case ESCAPE:
10111 case EXCEPT:
10112 case EXCEPTIONS:
10113 case EXIT:
10114 case EXTERNAL:
10115 case EXTENDS:
10116 case EXTRACT:
10117 case FALSE:
10118 case FINAL:
10119 case FORCE:
10120 case FUNCTION:
10121 case GLOBAL:
10122 case HASH:
10123 case HEAP:
10124 case HOUR:
10125 case IMMEDIATE:
10126 case INDICES:
10127 case INDEXTYPE:
10128 case INDICATOR:
10129 case INSTANTIABLE:
10130 case INTERVAL:
10131 case INVALIDATE:
10132 case ISOLATION:
10133 case JAVA:
10134 case LEVEL:
10135 case LIMIT:
10136 case LOOP:
10137 case MAP:
10138 case MAX:
10139 case MEMBER:
10140 case MERGE:
10141 case MIN:
10142 case MINUTE:
10143 case MLSLABEL:
10144 case MODIFY:
10145 case MOD:
10146 case MONTH:
10147 case NATURAL:
10148 case NEW:
10149 case NEW_DOT:
10150 case NO:
10151 case NONEDITIONABLE:
10152 case NOT:
10153 case NULL:
10154 case NULLIF:
10155 case OBJECT:
10156 case OID:
10157 case OPAQUE:
10158 case OPEN:
10159 case OPERATOR:
10160 case ORGANIZATION:
10161 case OTHERS:
10162 case OVERRIDING:
10163 case PACKAGE:
10164 case PARTITION:
10165 case PRESERVE:
10166 case PRIVATE:
10167 case PROCEDURE:
10168 case RANGE:
10169 case RAW:
10170 case REAL:
10171 case RECORD:
10172 case REF:
10173 case RELEASE:
10174 case RELIES_ON:
10175 case RENAME:
10176 case RESULT:
10177 case RETURN:
10178 case RETURNING:
10179 case REVERSE:
10180 case ROLLBACK:
10181 case ROW:
10182 case ROWS:
10183 case ROWID:
10184 case ROWNUM:
10185 case SAVE:
10186 case SAVEPOINT:
10187 case SECOND:
10188 case SELECT:
10189 case SELF:
10190 case SET:
10191 case SPACE:
10192 case SQL:
10193 case SQLCODE:
10194 case SQLERRM:
10195 case STATIC:
10196 case SUBTYPE:
10197 case SUBSTITUTABLE:
10198 case SUCCESSFUL:
10199 case SYSDATE:
10200 case SYS_REFCURSOR:
10201 case TEMPORARY:
10202 case TIME:
10203 case TIMESTAMP:
10204 case TIMEZONE_REGION:
10205 case TIMEZONE_ABBR:
10206 case TIMEZONE_MINUTE:
10207 case TIMEZONE_HOUR:
10208 case TRANSACTION:
10209 case TRUE:
10210 case TYPE:
10211 case UNDER:
10212 case USING:
10213 case YES:
10214 case SHOW:
10215 case A:
10216 case DOUBLE:
10217 case DEC:
10218 case PRECISION:
10219 case INT:
10220 case NUMERIC:
10221 case NCHAR:
10222 case NVARCHAR2:
10223 case STRING:
10224 case UROWID:
10225 case VARRAY:
10226 case VARYING:
10227 case BFILE:
10228 case BLOB:
10229 case CLOB:
10230 case NCLOB:
10231 case YEAR:
10232 case LOCAL:
10233 case WITH:
10234 case ZONE:
10235 case CHARACTER:
10236 case AFTER:
10237 case BEFORE:
10238 case OLD:
10239 case PARENT:
10240 case CC_IF:
10241 case ANALYZE:
10242 case ASSOCIATE:
10243 case AUDIT:
10244 case COMPOUND:
10245 case DATABASE:
10246 case CALL:
10247 case DDL:
10248 case DISASSOCIATE:
10249 case EACH:
10250 case FOLLOWS:
10251 case LOGOFF:
10252 case LOGON:
10253 case NESTED:
10254 case NOAUDIT:
10255 case SCHEMA:
10256 case SERVERERROR:
10257 case SHUTDOWN:
10258 case STARTUP:
10259 case STATEMENT:
10260 case STATISTICS:
10261 case SUSPEND:
10262 case TRUNCATE:
10263 case WRAPPED:
10264 case LIBRARY:
10265 case NAME:
10266 case STRUCT:
10267 case CONTEXT:
10268 case PARAMETERS:
10269 case LENGTH:
10270 case TDO:
10271 case MAXLEN:
10272 case CHARSETID:
10273 case CHARSETFORM:
10274 case ACCEPT:
10275 case ACCESSIBLE:
10276 case COPY:
10277 case DEFINE:
10278 case DISCONNECT:
10279 case HOST:
10280 case PRINT:
10281 case QUIT:
10282 case REMARK:
10283 case UNDEFINE:
10284 case VARIABLE:
10285 case WHENEVER:
10286 case ATTACH:
10287 case CAST:
10288 case TREAT:
10289 case TRIM:
10290 case LEFT:
10291 case RIGHT:
10292 case BOTH:
10293 case EMPTY:
10294 case MULTISET:
10295 case SUBMULTISET:
10296 case LEADING:
10297 case TRAILING:
10298 case CHAR_CS:
10299 case NCHAR_CS:
10300 case DBTIMEZONE:
10301 case SESSIONTIMEZONE:
10302 case AUTHENTICATED:
10303 case LINK:
10304 case SHARED:
10305 case DIRECTORY:
10306 case USER:
10307 case IDENTIFIER:
10308 case UNSIGNED_NUMERIC_LITERAL:
10309 case CHARACTER_LITERAL:
10310 case STRING_LITERAL:
10311 case QUOTED_LITERAL:
10312 Expression();
10313 break;
10314 default:
10315 jj_la1[124] = jj_gen;
10316 ;
10317 }
10318 label_25:
10319 while (true) {
10320 switch (jj_nt.kind) {
10321 case WHEN:
10322 ;
10323 break;
10324 default:
10325 jj_la1[125] = jj_gen;
10326 break label_25;
10327 }
10328 CaseWhenClause();
10329 }
10330 switch (jj_nt.kind) {
10331 case ELSE:
10332 ElseClause();
10333 break;
10334 default:
10335 jj_la1[126] = jj_gen;
10336 ;
10337 }
10338 jj_consume_token(END);
10339 jj_consume_token(CASE);
10340 switch (jj_nt.kind) {
10341 case IDENTIFIER:
10342 jj_consume_token(IDENTIFIER);
10343 break;
10344 default:
10345 jj_la1[127] = jj_gen;
10346 ;
10347 }
10348 jjtree.closeNodeScope(jjtn000, true);
10349 jjtc000 = false;
10350 {if (true) return jjtn000 ;}
10351 } catch (Throwable jjte000) {
10352 if (jjtc000) {
10353 jjtree.clearNodeScope(jjtn000);
10354 jjtc000 = false;
10355 } else {
10356 jjtree.popNode();
10357 }
10358 if (jjte000 instanceof RuntimeException) {
10359 {if (true) throw (RuntimeException)jjte000;}
10360 }
10361 if (jjte000 instanceof ParseException) {
10362 {if (true) throw (ParseException)jjte000;}
10363 }
10364 {if (true) throw (Error)jjte000;}
10365 } finally {
10366 if (jjtc000) {
10367 jjtree.closeNodeScope(jjtn000, true);
10368 }
10369 }
10370 throw new Error("Missing return statement in function");
10371 }
10372
10373 final public ASTCaseWhenClause CaseWhenClause() throws ParseException {
10374
10375 ASTCaseWhenClause jjtn000 = new ASTCaseWhenClause(this, JJTCASEWHENCLAUSE);
10376 boolean jjtc000 = true;
10377 jjtree.openNodeScope(jjtn000);
10378 try {
10379 jj_consume_token(WHEN);
10380 Expression();
10381 jj_consume_token(THEN);
10382 label_26:
10383 while (true) {
10384 Statement();
10385 switch (jj_nt.kind) {
10386 case 5:
10387 case 16:
10388 case 17:
10389 case 21:
10390 case REPLACE:
10391 case DEFINER:
10392 case CURRENT_USER:
10393 case LANGUAGE:
10394 case INLINE:
10395 case ADD:
10396 case AGGREGATE:
10397 case ARRAY:
10398 case AT:
10399 case ATTRIBUTE:
10400 case AUTHID:
10401 case BEGIN:
10402 case BODY:
10403 case BULK:
10404 case BYTE:
10405 case CASCADE:
10406 case CASE:
10407 case CLOSE:
10408 case COALESCE:
10409 case COLLECT:
10410 case COLUMN:
10411 case COMMENT:
10412 case COMMIT:
10413 case CONSTRUCTOR:
10414 case CONTINUE:
10415 case CONVERT:
10416 case CURRENT:
10417 case CURSOR:
10418 case DATA:
10419 case DATE:
10420 case DAY:
10421 case DECLARE:
10422 case DELETE:
10423 case DISABLE:
10424 case EDITIONABLE:
10425 case ELEMENT:
10426 case ENABLE:
10427 case ESCAPE:
10428 case EXCEPT:
10429 case EXCEPTIONS:
10430 case EXECUTE:
10431 case EXIT:
10432 case EXTERNAL:
10433 case EXTENDS:
10434 case EXTRACT:
10435 case FALSE:
10436 case FETCH:
10437 case FINAL:
10438 case FOR:
10439 case FORALL:
10440 case FORCE:
10441 case FUNCTION:
10442 case GLOBAL:
10443 case GOTO:
10444 case HASH:
10445 case HEAP:
10446 case HOUR:
10447 case IF:
10448 case IMMEDIATE:
10449 case INDICES:
10450 case INDEXTYPE:
10451 case INDICATOR:
10452 case INSERT:
10453 case INSTANTIABLE:
10454 case INTERVAL:
10455 case INVALIDATE:
10456 case ISOLATION:
10457 case JAVA:
10458 case LEVEL:
10459 case LIMIT:
10460 case LOCK:
10461 case LOOP:
10462 case MAP:
10463 case MAX:
10464 case MEMBER:
10465 case MERGE:
10466 case MIN:
10467 case MINUTE:
10468 case MLSLABEL:
10469 case MODIFY:
10470 case MOD:
10471 case MONTH:
10472 case NATURAL:
10473 case NEW:
10474 case NEW_DOT:
10475 case NO:
10476 case NONEDITIONABLE:
10477 case NOT:
10478 case NULL:
10479 case NULLIF:
10480 case OBJECT:
10481 case OID:
10482 case OPAQUE:
10483 case OPEN:
10484 case OPERATOR:
10485 case ORGANIZATION:
10486 case OTHERS:
10487 case OVERRIDING:
10488 case PACKAGE:
10489 case PARTITION:
10490 case PIPE:
10491 case PRAGMA:
10492 case PRESERVE:
10493 case PRIVATE:
10494 case PROCEDURE:
10495 case RAISE:
10496 case RANGE:
10497 case RAW:
10498 case REAL:
10499 case RECORD:
10500 case REF:
10501 case RELEASE:
10502 case RELIES_ON:
10503 case RENAME:
10504 case RESULT:
10505 case RETURN:
10506 case RETURNING:
10507 case REVERSE:
10508 case ROLLBACK:
10509 case ROW:
10510 case ROWS:
10511 case ROWID:
10512 case ROWNUM:
10513 case SAVE:
10514 case SAVEPOINT:
10515 case SECOND:
10516 case SELECT:
10517 case SELF:
10518 case SET:
10519 case SPACE:
10520 case SQL:
10521 case SQLCODE:
10522 case SQLERRM:
10523 case STATIC:
10524 case SUBTYPE:
10525 case SUBSTITUTABLE:
10526 case SUCCESSFUL:
10527 case SYSDATE:
10528 case SYS_REFCURSOR:
10529 case TEMPORARY:
10530 case TIME:
10531 case TIMESTAMP:
10532 case TIMEZONE_REGION:
10533 case TIMEZONE_ABBR:
10534 case TIMEZONE_MINUTE:
10535 case TIMEZONE_HOUR:
10536 case TRANSACTION:
10537 case TRUE:
10538 case TYPE:
10539 case UNDER:
10540 case USING:
10541 case WHILE:
10542 case YES:
10543 case SHOW:
10544 case A:
10545 case UPDATE:
10546 case DOUBLE:
10547 case DEC:
10548 case PRECISION:
10549 case INT:
10550 case NUMERIC:
10551 case NCHAR:
10552 case NVARCHAR2:
10553 case STRING:
10554 case UROWID:
10555 case VARRAY:
10556 case VARYING:
10557 case BFILE:
10558 case BLOB:
10559 case CLOB:
10560 case NCLOB:
10561 case YEAR:
10562 case LOCAL:
10563 case WITH:
10564 case ZONE:
10565 case CHARACTER:
10566 case AFTER:
10567 case BEFORE:
10568 case OLD:
10569 case PARENT:
10570 case CC_IF:
10571 case CC_ERROR:
10572 case ANALYZE:
10573 case ASSOCIATE:
10574 case AUDIT:
10575 case COMPOUND:
10576 case DATABASE:
10577 case CALL:
10578 case DDL:
10579 case DISASSOCIATE:
10580 case EACH:
10581 case FOLLOWS:
10582 case LOGOFF:
10583 case LOGON:
10584 case NESTED:
10585 case NOAUDIT:
10586 case SCHEMA:
10587 case SERVERERROR:
10588 case SHUTDOWN:
10589 case STARTUP:
10590 case STATEMENT:
10591 case STATISTICS:
10592 case SUSPEND:
10593 case TRUNCATE:
10594 case WRAPPED:
10595 case LIBRARY:
10596 case NAME:
10597 case STRUCT:
10598 case CONTEXT:
10599 case PARAMETERS:
10600 case LENGTH:
10601 case TDO:
10602 case MAXLEN:
10603 case CHARSETID:
10604 case CHARSETFORM:
10605 case ACCEPT:
10606 case ACCESSIBLE:
10607 case COPY:
10608 case DEFINE:
10609 case DISCONNECT:
10610 case HOST:
10611 case PRINT:
10612 case QUIT:
10613 case REMARK:
10614 case UNDEFINE:
10615 case VARIABLE:
10616 case WHENEVER:
10617 case ATTACH:
10618 case CAST:
10619 case TREAT:
10620 case TRIM:
10621 case LEFT:
10622 case RIGHT:
10623 case BOTH:
10624 case EMPTY:
10625 case MULTISET:
10626 case SUBMULTISET:
10627 case LEADING:
10628 case TRAILING:
10629 case CHAR_CS:
10630 case NCHAR_CS:
10631 case DBTIMEZONE:
10632 case SESSIONTIMEZONE:
10633 case AUTHENTICATED:
10634 case LINK:
10635 case SHARED:
10636 case DIRECTORY:
10637 case USER:
10638 case IDENTIFIER:
10639 case UNSIGNED_NUMERIC_LITERAL:
10640 case CHARACTER_LITERAL:
10641 case STRING_LITERAL:
10642 case QUOTED_LITERAL:
10643 ;
10644 break;
10645 default:
10646 jj_la1[128] = jj_gen;
10647 break label_26;
10648 }
10649 }
10650 jjtree.closeNodeScope(jjtn000, true);
10651 jjtc000 = false;
10652 {if (true) return jjtn000 ;}
10653 } catch (Throwable jjte000) {
10654 if (jjtc000) {
10655 jjtree.clearNodeScope(jjtn000);
10656 jjtc000 = false;
10657 } else {
10658 jjtree.popNode();
10659 }
10660 if (jjte000 instanceof RuntimeException) {
10661 {if (true) throw (RuntimeException)jjte000;}
10662 }
10663 if (jjte000 instanceof ParseException) {
10664 {if (true) throw (ParseException)jjte000;}
10665 }
10666 {if (true) throw (Error)jjte000;}
10667 } finally {
10668 if (jjtc000) {
10669 jjtree.closeNodeScope(jjtn000, true);
10670 }
10671 }
10672 throw new Error("Missing return statement in function");
10673 }
10674
10675 final public ASTElseClause ElseClause() throws ParseException {
10676
10677 ASTElseClause jjtn000 = new ASTElseClause(this, JJTELSECLAUSE);
10678 boolean jjtc000 = true;
10679 jjtree.openNodeScope(jjtn000);
10680 try {
10681 jj_consume_token(ELSE);
10682 label_27:
10683 while (true) {
10684 Statement();
10685 switch (jj_nt.kind) {
10686 case 5:
10687 case 16:
10688 case 17:
10689 case 21:
10690 case REPLACE:
10691 case DEFINER:
10692 case CURRENT_USER:
10693 case LANGUAGE:
10694 case INLINE:
10695 case ADD:
10696 case AGGREGATE:
10697 case ARRAY:
10698 case AT:
10699 case ATTRIBUTE:
10700 case AUTHID:
10701 case BEGIN:
10702 case BODY:
10703 case BULK:
10704 case BYTE:
10705 case CASCADE:
10706 case CASE:
10707 case CLOSE:
10708 case COALESCE:
10709 case COLLECT:
10710 case COLUMN:
10711 case COMMENT:
10712 case COMMIT:
10713 case CONSTRUCTOR:
10714 case CONTINUE:
10715 case CONVERT:
10716 case CURRENT:
10717 case CURSOR:
10718 case DATA:
10719 case DATE:
10720 case DAY:
10721 case DECLARE:
10722 case DELETE:
10723 case DISABLE:
10724 case EDITIONABLE:
10725 case ELEMENT:
10726 case ENABLE:
10727 case ESCAPE:
10728 case EXCEPT:
10729 case EXCEPTIONS:
10730 case EXECUTE:
10731 case EXIT:
10732 case EXTERNAL:
10733 case EXTENDS:
10734 case EXTRACT:
10735 case FALSE:
10736 case FETCH:
10737 case FINAL:
10738 case FOR:
10739 case FORALL:
10740 case FORCE:
10741 case FUNCTION:
10742 case GLOBAL:
10743 case GOTO:
10744 case HASH:
10745 case HEAP:
10746 case HOUR:
10747 case IF:
10748 case IMMEDIATE:
10749 case INDICES:
10750 case INDEXTYPE:
10751 case INDICATOR:
10752 case INSERT:
10753 case INSTANTIABLE:
10754 case INTERVAL:
10755 case INVALIDATE:
10756 case ISOLATION:
10757 case JAVA:
10758 case LEVEL:
10759 case LIMIT:
10760 case LOCK:
10761 case LOOP:
10762 case MAP:
10763 case MAX:
10764 case MEMBER:
10765 case MERGE:
10766 case MIN:
10767 case MINUTE:
10768 case MLSLABEL:
10769 case MODIFY:
10770 case MOD:
10771 case MONTH:
10772 case NATURAL:
10773 case NEW:
10774 case NEW_DOT:
10775 case NO:
10776 case NONEDITIONABLE:
10777 case NOT:
10778 case NULL:
10779 case NULLIF:
10780 case OBJECT:
10781 case OID:
10782 case OPAQUE:
10783 case OPEN:
10784 case OPERATOR:
10785 case ORGANIZATION:
10786 case OTHERS:
10787 case OVERRIDING:
10788 case PACKAGE:
10789 case PARTITION:
10790 case PIPE:
10791 case PRAGMA:
10792 case PRESERVE:
10793 case PRIVATE:
10794 case PROCEDURE:
10795 case RAISE:
10796 case RANGE:
10797 case RAW:
10798 case REAL:
10799 case RECORD:
10800 case REF:
10801 case RELEASE:
10802 case RELIES_ON:
10803 case RENAME:
10804 case RESULT:
10805 case RETURN:
10806 case RETURNING:
10807 case REVERSE:
10808 case ROLLBACK:
10809 case ROW:
10810 case ROWS:
10811 case ROWID:
10812 case ROWNUM:
10813 case SAVE:
10814 case SAVEPOINT:
10815 case SECOND:
10816 case SELECT:
10817 case SELF:
10818 case SET:
10819 case SPACE:
10820 case SQL:
10821 case SQLCODE:
10822 case SQLERRM:
10823 case STATIC:
10824 case SUBTYPE:
10825 case SUBSTITUTABLE:
10826 case SUCCESSFUL:
10827 case SYSDATE:
10828 case SYS_REFCURSOR:
10829 case TEMPORARY:
10830 case TIME:
10831 case TIMESTAMP:
10832 case TIMEZONE_REGION:
10833 case TIMEZONE_ABBR:
10834 case TIMEZONE_MINUTE:
10835 case TIMEZONE_HOUR:
10836 case TRANSACTION:
10837 case TRUE:
10838 case TYPE:
10839 case UNDER:
10840 case USING:
10841 case WHILE:
10842 case YES:
10843 case SHOW:
10844 case A:
10845 case UPDATE:
10846 case DOUBLE:
10847 case DEC:
10848 case PRECISION:
10849 case INT:
10850 case NUMERIC:
10851 case NCHAR:
10852 case NVARCHAR2:
10853 case STRING:
10854 case UROWID:
10855 case VARRAY:
10856 case VARYING:
10857 case BFILE:
10858 case BLOB:
10859 case CLOB:
10860 case NCLOB:
10861 case YEAR:
10862 case LOCAL:
10863 case WITH:
10864 case ZONE:
10865 case CHARACTER:
10866 case AFTER:
10867 case BEFORE:
10868 case OLD:
10869 case PARENT:
10870 case CC_IF:
10871 case CC_ERROR:
10872 case ANALYZE:
10873 case ASSOCIATE:
10874 case AUDIT:
10875 case COMPOUND:
10876 case DATABASE:
10877 case CALL:
10878 case DDL:
10879 case DISASSOCIATE:
10880 case EACH:
10881 case FOLLOWS:
10882 case LOGOFF:
10883 case LOGON:
10884 case NESTED:
10885 case NOAUDIT:
10886 case SCHEMA:
10887 case SERVERERROR:
10888 case SHUTDOWN:
10889 case STARTUP:
10890 case STATEMENT:
10891 case STATISTICS:
10892 case SUSPEND:
10893 case TRUNCATE:
10894 case WRAPPED:
10895 case LIBRARY:
10896 case NAME:
10897 case STRUCT:
10898 case CONTEXT:
10899 case PARAMETERS:
10900 case LENGTH:
10901 case TDO:
10902 case MAXLEN:
10903 case CHARSETID:
10904 case CHARSETFORM:
10905 case ACCEPT:
10906 case ACCESSIBLE:
10907 case COPY:
10908 case DEFINE:
10909 case DISCONNECT:
10910 case HOST:
10911 case PRINT:
10912 case QUIT:
10913 case REMARK:
10914 case UNDEFINE:
10915 case VARIABLE:
10916 case WHENEVER:
10917 case ATTACH:
10918 case CAST:
10919 case TREAT:
10920 case TRIM:
10921 case LEFT:
10922 case RIGHT:
10923 case BOTH:
10924 case EMPTY:
10925 case MULTISET:
10926 case SUBMULTISET:
10927 case LEADING:
10928 case TRAILING:
10929 case CHAR_CS:
10930 case NCHAR_CS:
10931 case DBTIMEZONE:
10932 case SESSIONTIMEZONE:
10933 case AUTHENTICATED:
10934 case LINK:
10935 case SHARED:
10936 case DIRECTORY:
10937 case USER:
10938 case IDENTIFIER:
10939 case UNSIGNED_NUMERIC_LITERAL:
10940 case CHARACTER_LITERAL:
10941 case STRING_LITERAL:
10942 case QUOTED_LITERAL:
10943 ;
10944 break;
10945 default:
10946 jj_la1[129] = jj_gen;
10947 break label_27;
10948 }
10949 }
10950 jjtree.closeNodeScope(jjtn000, true);
10951 jjtc000 = false;
10952 {if (true) return jjtn000 ;}
10953 } catch (Throwable jjte000) {
10954 if (jjtc000) {
10955 jjtree.clearNodeScope(jjtn000);
10956 jjtc000 = false;
10957 } else {
10958 jjtree.popNode();
10959 }
10960 if (jjte000 instanceof RuntimeException) {
10961 {if (true) throw (RuntimeException)jjte000;}
10962 }
10963 if (jjte000 instanceof ParseException) {
10964 {if (true) throw (ParseException)jjte000;}
10965 }
10966 {if (true) throw (Error)jjte000;}
10967 } finally {
10968 if (jjtc000) {
10969 jjtree.closeNodeScope(jjtn000, true);
10970 }
10971 }
10972 throw new Error("Missing return statement in function");
10973 }
10974
10975 final public ASTElsifClause ElsifClause() throws ParseException {
10976
10977 ASTElsifClause jjtn000 = new ASTElsifClause(this, JJTELSIFCLAUSE);
10978 boolean jjtc000 = true;
10979 jjtree.openNodeScope(jjtn000);
10980 try {
10981 jj_consume_token(ELSIF);
10982 Expression();
10983 jj_consume_token(THEN);
10984 label_28:
10985 while (true) {
10986 Statement();
10987 switch (jj_nt.kind) {
10988 case 5:
10989 case 16:
10990 case 17:
10991 case 21:
10992 case REPLACE:
10993 case DEFINER:
10994 case CURRENT_USER:
10995 case LANGUAGE:
10996 case INLINE:
10997 case ADD:
10998 case AGGREGATE:
10999 case ARRAY:
11000 case AT:
11001 case ATTRIBUTE:
11002 case AUTHID:
11003 case BEGIN:
11004 case BODY:
11005 case BULK:
11006 case BYTE:
11007 case CASCADE:
11008 case CASE:
11009 case CLOSE:
11010 case COALESCE:
11011 case COLLECT:
11012 case COLUMN:
11013 case COMMENT:
11014 case COMMIT:
11015 case CONSTRUCTOR:
11016 case CONTINUE:
11017 case CONVERT:
11018 case CURRENT:
11019 case CURSOR:
11020 case DATA:
11021 case DATE:
11022 case DAY:
11023 case DECLARE:
11024 case DELETE:
11025 case DISABLE:
11026 case EDITIONABLE:
11027 case ELEMENT:
11028 case ENABLE:
11029 case ESCAPE:
11030 case EXCEPT:
11031 case EXCEPTIONS:
11032 case EXECUTE:
11033 case EXIT:
11034 case EXTERNAL:
11035 case EXTENDS:
11036 case EXTRACT:
11037 case FALSE:
11038 case FETCH:
11039 case FINAL:
11040 case FOR:
11041 case FORALL:
11042 case FORCE:
11043 case FUNCTION:
11044 case GLOBAL:
11045 case GOTO:
11046 case HASH:
11047 case HEAP:
11048 case HOUR:
11049 case IF:
11050 case IMMEDIATE:
11051 case INDICES:
11052 case INDEXTYPE:
11053 case INDICATOR:
11054 case INSERT:
11055 case INSTANTIABLE:
11056 case INTERVAL:
11057 case INVALIDATE:
11058 case ISOLATION:
11059 case JAVA:
11060 case LEVEL:
11061 case LIMIT:
11062 case LOCK:
11063 case LOOP:
11064 case MAP:
11065 case MAX:
11066 case MEMBER:
11067 case MERGE:
11068 case MIN:
11069 case MINUTE:
11070 case MLSLABEL:
11071 case MODIFY:
11072 case MOD:
11073 case MONTH:
11074 case NATURAL:
11075 case NEW:
11076 case NEW_DOT:
11077 case NO:
11078 case NONEDITIONABLE:
11079 case NOT:
11080 case NULL:
11081 case NULLIF:
11082 case OBJECT:
11083 case OID:
11084 case OPAQUE:
11085 case OPEN:
11086 case OPERATOR:
11087 case ORGANIZATION:
11088 case OTHERS:
11089 case OVERRIDING:
11090 case PACKAGE:
11091 case PARTITION:
11092 case PIPE:
11093 case PRAGMA:
11094 case PRESERVE:
11095 case PRIVATE:
11096 case PROCEDURE:
11097 case RAISE:
11098 case RANGE:
11099 case RAW:
11100 case REAL:
11101 case RECORD:
11102 case REF:
11103 case RELEASE:
11104 case RELIES_ON:
11105 case RENAME:
11106 case RESULT:
11107 case RETURN:
11108 case RETURNING:
11109 case REVERSE:
11110 case ROLLBACK:
11111 case ROW:
11112 case ROWS:
11113 case ROWID:
11114 case ROWNUM:
11115 case SAVE:
11116 case SAVEPOINT:
11117 case SECOND:
11118 case SELECT:
11119 case SELF:
11120 case SET:
11121 case SPACE:
11122 case SQL:
11123 case SQLCODE:
11124 case SQLERRM:
11125 case STATIC:
11126 case SUBTYPE:
11127 case SUBSTITUTABLE:
11128 case SUCCESSFUL:
11129 case SYSDATE:
11130 case SYS_REFCURSOR:
11131 case TEMPORARY:
11132 case TIME:
11133 case TIMESTAMP:
11134 case TIMEZONE_REGION:
11135 case TIMEZONE_ABBR:
11136 case TIMEZONE_MINUTE:
11137 case TIMEZONE_HOUR:
11138 case TRANSACTION:
11139 case TRUE:
11140 case TYPE:
11141 case UNDER:
11142 case USING:
11143 case WHILE:
11144 case YES:
11145 case SHOW:
11146 case A:
11147 case UPDATE:
11148 case DOUBLE:
11149 case DEC:
11150 case PRECISION:
11151 case INT:
11152 case NUMERIC:
11153 case NCHAR:
11154 case NVARCHAR2:
11155 case STRING:
11156 case UROWID:
11157 case VARRAY:
11158 case VARYING:
11159 case BFILE:
11160 case BLOB:
11161 case CLOB:
11162 case NCLOB:
11163 case YEAR:
11164 case LOCAL:
11165 case WITH:
11166 case ZONE:
11167 case CHARACTER:
11168 case AFTER:
11169 case BEFORE:
11170 case OLD:
11171 case PARENT:
11172 case CC_IF:
11173 case CC_ERROR:
11174 case ANALYZE:
11175 case ASSOCIATE:
11176 case AUDIT:
11177 case COMPOUND:
11178 case DATABASE:
11179 case CALL:
11180 case DDL:
11181 case DISASSOCIATE:
11182 case EACH:
11183 case FOLLOWS:
11184 case LOGOFF:
11185 case LOGON:
11186 case NESTED:
11187 case NOAUDIT:
11188 case SCHEMA:
11189 case SERVERERROR:
11190 case SHUTDOWN:
11191 case STARTUP:
11192 case STATEMENT:
11193 case STATISTICS:
11194 case SUSPEND:
11195 case TRUNCATE:
11196 case WRAPPED:
11197 case LIBRARY:
11198 case NAME:
11199 case STRUCT:
11200 case CONTEXT:
11201 case PARAMETERS:
11202 case LENGTH:
11203 case TDO:
11204 case MAXLEN:
11205 case CHARSETID:
11206 case CHARSETFORM:
11207 case ACCEPT:
11208 case ACCESSIBLE:
11209 case COPY:
11210 case DEFINE:
11211 case DISCONNECT:
11212 case HOST:
11213 case PRINT:
11214 case QUIT:
11215 case REMARK:
11216 case UNDEFINE:
11217 case VARIABLE:
11218 case WHENEVER:
11219 case ATTACH:
11220 case CAST:
11221 case TREAT:
11222 case TRIM:
11223 case LEFT:
11224 case RIGHT:
11225 case BOTH:
11226 case EMPTY:
11227 case MULTISET:
11228 case SUBMULTISET:
11229 case LEADING:
11230 case TRAILING:
11231 case CHAR_CS:
11232 case NCHAR_CS:
11233 case DBTIMEZONE:
11234 case SESSIONTIMEZONE:
11235 case AUTHENTICATED:
11236 case LINK:
11237 case SHARED:
11238 case DIRECTORY:
11239 case USER:
11240 case IDENTIFIER:
11241 case UNSIGNED_NUMERIC_LITERAL:
11242 case CHARACTER_LITERAL:
11243 case STRING_LITERAL:
11244 case QUOTED_LITERAL:
11245 ;
11246 break;
11247 default:
11248 jj_la1[130] = jj_gen;
11249 break label_28;
11250 }
11251 }
11252 jjtree.closeNodeScope(jjtn000, true);
11253 jjtc000 = false;
11254 {if (true) return jjtn000 ;}
11255 } catch (Throwable jjte000) {
11256 if (jjtc000) {
11257 jjtree.clearNodeScope(jjtn000);
11258 jjtc000 = false;
11259 } else {
11260 jjtree.popNode();
11261 }
11262 if (jjte000 instanceof RuntimeException) {
11263 {if (true) throw (RuntimeException)jjte000;}
11264 }
11265 if (jjte000 instanceof ParseException) {
11266 {if (true) throw (ParseException)jjte000;}
11267 }
11268 {if (true) throw (Error)jjte000;}
11269 } finally {
11270 if (jjtc000) {
11271 jjtree.closeNodeScope(jjtn000, true);
11272 }
11273 }
11274 throw new Error("Missing return statement in function");
11275 }
11276
11277 final public ASTLoopStatement LoopStatement() throws ParseException {
11278
11279 ASTLoopStatement jjtn000 = new ASTLoopStatement(this, JJTLOOPSTATEMENT);
11280 boolean jjtc000 = true;
11281 jjtree.openNodeScope(jjtn000);
11282 try {
11283 jj_consume_token(LOOP);
11284 label_29:
11285 while (true) {
11286 Statement();
11287 switch (jj_nt.kind) {
11288 case 5:
11289 case 16:
11290 case 17:
11291 case 21:
11292 case REPLACE:
11293 case DEFINER:
11294 case CURRENT_USER:
11295 case LANGUAGE:
11296 case INLINE:
11297 case ADD:
11298 case AGGREGATE:
11299 case ARRAY:
11300 case AT:
11301 case ATTRIBUTE:
11302 case AUTHID:
11303 case BEGIN:
11304 case BODY:
11305 case BULK:
11306 case BYTE:
11307 case CASCADE:
11308 case CASE:
11309 case CLOSE:
11310 case COALESCE:
11311 case COLLECT:
11312 case COLUMN:
11313 case COMMENT:
11314 case COMMIT:
11315 case CONSTRUCTOR:
11316 case CONTINUE:
11317 case CONVERT:
11318 case CURRENT:
11319 case CURSOR:
11320 case DATA:
11321 case DATE:
11322 case DAY:
11323 case DECLARE:
11324 case DELETE:
11325 case DISABLE:
11326 case EDITIONABLE:
11327 case ELEMENT:
11328 case ENABLE:
11329 case ESCAPE:
11330 case EXCEPT:
11331 case EXCEPTIONS:
11332 case EXECUTE:
11333 case EXIT:
11334 case EXTERNAL:
11335 case EXTENDS:
11336 case EXTRACT:
11337 case FALSE:
11338 case FETCH:
11339 case FINAL:
11340 case FOR:
11341 case FORALL:
11342 case FORCE:
11343 case FUNCTION:
11344 case GLOBAL:
11345 case GOTO:
11346 case HASH:
11347 case HEAP:
11348 case HOUR:
11349 case IF:
11350 case IMMEDIATE:
11351 case INDICES:
11352 case INDEXTYPE:
11353 case INDICATOR:
11354 case INSERT:
11355 case INSTANTIABLE:
11356 case INTERVAL:
11357 case INVALIDATE:
11358 case ISOLATION:
11359 case JAVA:
11360 case LEVEL:
11361 case LIMIT:
11362 case LOCK:
11363 case LOOP:
11364 case MAP:
11365 case MAX:
11366 case MEMBER:
11367 case MERGE:
11368 case MIN:
11369 case MINUTE:
11370 case MLSLABEL:
11371 case MODIFY:
11372 case MOD:
11373 case MONTH:
11374 case NATURAL:
11375 case NEW:
11376 case NEW_DOT:
11377 case NO:
11378 case NONEDITIONABLE:
11379 case NOT:
11380 case NULL:
11381 case NULLIF:
11382 case OBJECT:
11383 case OID:
11384 case OPAQUE:
11385 case OPEN:
11386 case OPERATOR:
11387 case ORGANIZATION:
11388 case OTHERS:
11389 case OVERRIDING:
11390 case PACKAGE:
11391 case PARTITION:
11392 case PIPE:
11393 case PRAGMA:
11394 case PRESERVE:
11395 case PRIVATE:
11396 case PROCEDURE:
11397 case RAISE:
11398 case RANGE:
11399 case RAW:
11400 case REAL:
11401 case RECORD:
11402 case REF:
11403 case RELEASE:
11404 case RELIES_ON:
11405 case RENAME:
11406 case RESULT:
11407 case RETURN:
11408 case RETURNING:
11409 case REVERSE:
11410 case ROLLBACK:
11411 case ROW:
11412 case ROWS:
11413 case ROWID:
11414 case ROWNUM:
11415 case SAVE:
11416 case SAVEPOINT:
11417 case SECOND:
11418 case SELECT:
11419 case SELF:
11420 case SET:
11421 case SPACE:
11422 case SQL:
11423 case SQLCODE:
11424 case SQLERRM:
11425 case STATIC:
11426 case SUBTYPE:
11427 case SUBSTITUTABLE:
11428 case SUCCESSFUL:
11429 case SYSDATE:
11430 case SYS_REFCURSOR:
11431 case TEMPORARY:
11432 case TIME:
11433 case TIMESTAMP:
11434 case TIMEZONE_REGION:
11435 case TIMEZONE_ABBR:
11436 case TIMEZONE_MINUTE:
11437 case TIMEZONE_HOUR:
11438 case TRANSACTION:
11439 case TRUE:
11440 case TYPE:
11441 case UNDER:
11442 case USING:
11443 case WHILE:
11444 case YES:
11445 case SHOW:
11446 case A:
11447 case UPDATE:
11448 case DOUBLE:
11449 case DEC:
11450 case PRECISION:
11451 case INT:
11452 case NUMERIC:
11453 case NCHAR:
11454 case NVARCHAR2:
11455 case STRING:
11456 case UROWID:
11457 case VARRAY:
11458 case VARYING:
11459 case BFILE:
11460 case BLOB:
11461 case CLOB:
11462 case NCLOB:
11463 case YEAR:
11464 case LOCAL:
11465 case WITH:
11466 case ZONE:
11467 case CHARACTER:
11468 case AFTER:
11469 case BEFORE:
11470 case OLD:
11471 case PARENT:
11472 case CC_IF:
11473 case CC_ERROR:
11474 case ANALYZE:
11475 case ASSOCIATE:
11476 case AUDIT:
11477 case COMPOUND:
11478 case DATABASE:
11479 case CALL:
11480 case DDL:
11481 case DISASSOCIATE:
11482 case EACH:
11483 case FOLLOWS:
11484 case LOGOFF:
11485 case LOGON:
11486 case NESTED:
11487 case NOAUDIT:
11488 case SCHEMA:
11489 case SERVERERROR:
11490 case SHUTDOWN:
11491 case STARTUP:
11492 case STATEMENT:
11493 case STATISTICS:
11494 case SUSPEND:
11495 case TRUNCATE:
11496 case WRAPPED:
11497 case LIBRARY:
11498 case NAME:
11499 case STRUCT:
11500 case CONTEXT:
11501 case PARAMETERS:
11502 case LENGTH:
11503 case TDO:
11504 case MAXLEN:
11505 case CHARSETID:
11506 case CHARSETFORM:
11507 case ACCEPT:
11508 case ACCESSIBLE:
11509 case COPY:
11510 case DEFINE:
11511 case DISCONNECT:
11512 case HOST:
11513 case PRINT:
11514 case QUIT:
11515 case REMARK:
11516 case UNDEFINE:
11517 case VARIABLE:
11518 case WHENEVER:
11519 case ATTACH:
11520 case CAST:
11521 case TREAT:
11522 case TRIM:
11523 case LEFT:
11524 case RIGHT:
11525 case BOTH:
11526 case EMPTY:
11527 case MULTISET:
11528 case SUBMULTISET:
11529 case LEADING:
11530 case TRAILING:
11531 case CHAR_CS:
11532 case NCHAR_CS:
11533 case DBTIMEZONE:
11534 case SESSIONTIMEZONE:
11535 case AUTHENTICATED:
11536 case LINK:
11537 case SHARED:
11538 case DIRECTORY:
11539 case USER:
11540 case IDENTIFIER:
11541 case UNSIGNED_NUMERIC_LITERAL:
11542 case CHARACTER_LITERAL:
11543 case STRING_LITERAL:
11544 case QUOTED_LITERAL:
11545 ;
11546 break;
11547 default:
11548 jj_la1[131] = jj_gen;
11549 break label_29;
11550 }
11551 }
11552 jj_consume_token(END);
11553 jj_consume_token(LOOP);
11554 switch (jj_nt.kind) {
11555 case IDENTIFIER:
11556 jj_consume_token(IDENTIFIER);
11557 break;
11558 default:
11559 jj_la1[132] = jj_gen;
11560 ;
11561 }
11562 jjtree.closeNodeScope(jjtn000, true);
11563 jjtc000 = false;
11564 {if (true) return jjtn000 ;}
11565 } catch (Throwable jjte000) {
11566 if (jjtc000) {
11567 jjtree.clearNodeScope(jjtn000);
11568 jjtc000 = false;
11569 } else {
11570 jjtree.popNode();
11571 }
11572 if (jjte000 instanceof RuntimeException) {
11573 {if (true) throw (RuntimeException)jjte000;}
11574 }
11575 if (jjte000 instanceof ParseException) {
11576 {if (true) throw (ParseException)jjte000;}
11577 }
11578 {if (true) throw (Error)jjte000;}
11579 } finally {
11580 if (jjtc000) {
11581 jjtree.closeNodeScope(jjtn000, true);
11582 }
11583 }
11584 throw new Error("Missing return statement in function");
11585 }
11586
11587
11588 final public ASTForStatement ForStatement() throws ParseException {
11589
11590 ASTForStatement jjtn000 = new ASTForStatement(this, JJTFORSTATEMENT);
11591 boolean jjtc000 = true;
11592 jjtree.openNodeScope(jjtn000);
11593 try {
11594 jj_consume_token(FOR);
11595 ForIndex();
11596 jj_consume_token(IN);
11597 switch (jj_nt.kind) {
11598 case REVERSE:
11599 jj_consume_token(REVERSE);
11600 break;
11601 default:
11602 jj_la1[133] = jj_gen;
11603 ;
11604 }
11605 Expression();
11606 switch (jj_nt.kind) {
11607 case 12:
11608 jj_consume_token(12);
11609 Expression();
11610 break;
11611 default:
11612 jj_la1[134] = jj_gen;
11613 ;
11614 }
11615 jj_consume_token(LOOP);
11616 label_30:
11617 while (true) {
11618 Statement();
11619 switch (jj_nt.kind) {
11620 case 5:
11621 case 16:
11622 case 17:
11623 case 21:
11624 case REPLACE:
11625 case DEFINER:
11626 case CURRENT_USER:
11627 case LANGUAGE:
11628 case INLINE:
11629 case ADD:
11630 case AGGREGATE:
11631 case ARRAY:
11632 case AT:
11633 case ATTRIBUTE:
11634 case AUTHID:
11635 case BEGIN:
11636 case BODY:
11637 case BULK:
11638 case BYTE:
11639 case CASCADE:
11640 case CASE:
11641 case CLOSE:
11642 case COALESCE:
11643 case COLLECT:
11644 case COLUMN:
11645 case COMMENT:
11646 case COMMIT:
11647 case CONSTRUCTOR:
11648 case CONTINUE:
11649 case CONVERT:
11650 case CURRENT:
11651 case CURSOR:
11652 case DATA:
11653 case DATE:
11654 case DAY:
11655 case DECLARE:
11656 case DELETE:
11657 case DISABLE:
11658 case EDITIONABLE:
11659 case ELEMENT:
11660 case ENABLE:
11661 case ESCAPE:
11662 case EXCEPT:
11663 case EXCEPTIONS:
11664 case EXECUTE:
11665 case EXIT:
11666 case EXTERNAL:
11667 case EXTENDS:
11668 case EXTRACT:
11669 case FALSE:
11670 case FETCH:
11671 case FINAL:
11672 case FOR:
11673 case FORALL:
11674 case FORCE:
11675 case FUNCTION:
11676 case GLOBAL:
11677 case GOTO:
11678 case HASH:
11679 case HEAP:
11680 case HOUR:
11681 case IF:
11682 case IMMEDIATE:
11683 case INDICES:
11684 case INDEXTYPE:
11685 case INDICATOR:
11686 case INSERT:
11687 case INSTANTIABLE:
11688 case INTERVAL:
11689 case INVALIDATE:
11690 case ISOLATION:
11691 case JAVA:
11692 case LEVEL:
11693 case LIMIT:
11694 case LOCK:
11695 case LOOP:
11696 case MAP:
11697 case MAX:
11698 case MEMBER:
11699 case MERGE:
11700 case MIN:
11701 case MINUTE:
11702 case MLSLABEL:
11703 case MODIFY:
11704 case MOD:
11705 case MONTH:
11706 case NATURAL:
11707 case NEW:
11708 case NEW_DOT:
11709 case NO:
11710 case NONEDITIONABLE:
11711 case NOT:
11712 case NULL:
11713 case NULLIF:
11714 case OBJECT:
11715 case OID:
11716 case OPAQUE:
11717 case OPEN:
11718 case OPERATOR:
11719 case ORGANIZATION:
11720 case OTHERS:
11721 case OVERRIDING:
11722 case PACKAGE:
11723 case PARTITION:
11724 case PIPE:
11725 case PRAGMA:
11726 case PRESERVE:
11727 case PRIVATE:
11728 case PROCEDURE:
11729 case RAISE:
11730 case RANGE:
11731 case RAW:
11732 case REAL:
11733 case RECORD:
11734 case REF:
11735 case RELEASE:
11736 case RELIES_ON:
11737 case RENAME:
11738 case RESULT:
11739 case RETURN:
11740 case RETURNING:
11741 case REVERSE:
11742 case ROLLBACK:
11743 case ROW:
11744 case ROWS:
11745 case ROWID:
11746 case ROWNUM:
11747 case SAVE:
11748 case SAVEPOINT:
11749 case SECOND:
11750 case SELECT:
11751 case SELF:
11752 case SET:
11753 case SPACE:
11754 case SQL:
11755 case SQLCODE:
11756 case SQLERRM:
11757 case STATIC:
11758 case SUBTYPE:
11759 case SUBSTITUTABLE:
11760 case SUCCESSFUL:
11761 case SYSDATE:
11762 case SYS_REFCURSOR:
11763 case TEMPORARY:
11764 case TIME:
11765 case TIMESTAMP:
11766 case TIMEZONE_REGION:
11767 case TIMEZONE_ABBR:
11768 case TIMEZONE_MINUTE:
11769 case TIMEZONE_HOUR:
11770 case TRANSACTION:
11771 case TRUE:
11772 case TYPE:
11773 case UNDER:
11774 case USING:
11775 case WHILE:
11776 case YES:
11777 case SHOW:
11778 case A:
11779 case UPDATE:
11780 case DOUBLE:
11781 case DEC:
11782 case PRECISION:
11783 case INT:
11784 case NUMERIC:
11785 case NCHAR:
11786 case NVARCHAR2:
11787 case STRING:
11788 case UROWID:
11789 case VARRAY:
11790 case VARYING:
11791 case BFILE:
11792 case BLOB:
11793 case CLOB:
11794 case NCLOB:
11795 case YEAR:
11796 case LOCAL:
11797 case WITH:
11798 case ZONE:
11799 case CHARACTER:
11800 case AFTER:
11801 case BEFORE:
11802 case OLD:
11803 case PARENT:
11804 case CC_IF:
11805 case CC_ERROR:
11806 case ANALYZE:
11807 case ASSOCIATE:
11808 case AUDIT:
11809 case COMPOUND:
11810 case DATABASE:
11811 case CALL:
11812 case DDL:
11813 case DISASSOCIATE:
11814 case EACH:
11815 case FOLLOWS:
11816 case LOGOFF:
11817 case LOGON:
11818 case NESTED:
11819 case NOAUDIT:
11820 case SCHEMA:
11821 case SERVERERROR:
11822 case SHUTDOWN:
11823 case STARTUP:
11824 case STATEMENT:
11825 case STATISTICS:
11826 case SUSPEND:
11827 case TRUNCATE:
11828 case WRAPPED:
11829 case LIBRARY:
11830 case NAME:
11831 case STRUCT:
11832 case CONTEXT:
11833 case PARAMETERS:
11834 case LENGTH:
11835 case TDO:
11836 case MAXLEN:
11837 case CHARSETID:
11838 case CHARSETFORM:
11839 case ACCEPT:
11840 case ACCESSIBLE:
11841 case COPY:
11842 case DEFINE:
11843 case DISCONNECT:
11844 case HOST:
11845 case PRINT:
11846 case QUIT:
11847 case REMARK:
11848 case UNDEFINE:
11849 case VARIABLE:
11850 case WHENEVER:
11851 case ATTACH:
11852 case CAST:
11853 case TREAT:
11854 case TRIM:
11855 case LEFT:
11856 case RIGHT:
11857 case BOTH:
11858 case EMPTY:
11859 case MULTISET:
11860 case SUBMULTISET:
11861 case LEADING:
11862 case TRAILING:
11863 case CHAR_CS:
11864 case NCHAR_CS:
11865 case DBTIMEZONE:
11866 case SESSIONTIMEZONE:
11867 case AUTHENTICATED:
11868 case LINK:
11869 case SHARED:
11870 case DIRECTORY:
11871 case USER:
11872 case IDENTIFIER:
11873 case UNSIGNED_NUMERIC_LITERAL:
11874 case CHARACTER_LITERAL:
11875 case STRING_LITERAL:
11876 case QUOTED_LITERAL:
11877 ;
11878 break;
11879 default:
11880 jj_la1[135] = jj_gen;
11881 break label_30;
11882 }
11883 }
11884 jj_consume_token(END);
11885 jj_consume_token(LOOP);
11886 switch (jj_nt.kind) {
11887 case IDENTIFIER:
11888 jj_consume_token(IDENTIFIER);
11889 break;
11890 default:
11891 jj_la1[136] = jj_gen;
11892 ;
11893 }
11894 jjtree.closeNodeScope(jjtn000, true);
11895 jjtc000 = false;
11896 {if (true) return jjtn000 ;}
11897 } catch (Throwable jjte000) {
11898 if (jjtc000) {
11899 jjtree.clearNodeScope(jjtn000);
11900 jjtc000 = false;
11901 } else {
11902 jjtree.popNode();
11903 }
11904 if (jjte000 instanceof RuntimeException) {
11905 {if (true) throw (RuntimeException)jjte000;}
11906 }
11907 if (jjte000 instanceof ParseException) {
11908 {if (true) throw (ParseException)jjte000;}
11909 }
11910 {if (true) throw (Error)jjte000;}
11911 } finally {
11912 if (jjtc000) {
11913 jjtree.closeNodeScope(jjtn000, true);
11914 }
11915 }
11916 throw new Error("Missing return statement in function");
11917 }
11918
11919 final public ASTWhileStatement WhileStatement() throws ParseException {
11920
11921 ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT);
11922 boolean jjtc000 = true;
11923 jjtree.openNodeScope(jjtn000);
11924 try {
11925 jj_consume_token(WHILE);
11926 Expression();
11927 jj_consume_token(LOOP);
11928 label_31:
11929 while (true) {
11930 Statement();
11931 switch (jj_nt.kind) {
11932 case 5:
11933 case 16:
11934 case 17:
11935 case 21:
11936 case REPLACE:
11937 case DEFINER:
11938 case CURRENT_USER:
11939 case LANGUAGE:
11940 case INLINE:
11941 case ADD:
11942 case AGGREGATE:
11943 case ARRAY:
11944 case AT:
11945 case ATTRIBUTE:
11946 case AUTHID:
11947 case BEGIN:
11948 case BODY:
11949 case BULK:
11950 case BYTE:
11951 case CASCADE:
11952 case CASE:
11953 case CLOSE:
11954 case COALESCE:
11955 case COLLECT:
11956 case COLUMN:
11957 case COMMENT:
11958 case COMMIT:
11959 case CONSTRUCTOR:
11960 case CONTINUE:
11961 case CONVERT:
11962 case CURRENT:
11963 case CURSOR:
11964 case DATA:
11965 case DATE:
11966 case DAY:
11967 case DECLARE:
11968 case DELETE:
11969 case DISABLE:
11970 case EDITIONABLE:
11971 case ELEMENT:
11972 case ENABLE:
11973 case ESCAPE:
11974 case EXCEPT:
11975 case EXCEPTIONS:
11976 case EXECUTE:
11977 case EXIT:
11978 case EXTERNAL:
11979 case EXTENDS:
11980 case EXTRACT:
11981 case FALSE:
11982 case FETCH:
11983 case FINAL:
11984 case FOR:
11985 case FORALL:
11986 case FORCE:
11987 case FUNCTION:
11988 case GLOBAL:
11989 case GOTO:
11990 case HASH:
11991 case HEAP:
11992 case HOUR:
11993 case IF:
11994 case IMMEDIATE:
11995 case INDICES:
11996 case INDEXTYPE:
11997 case INDICATOR:
11998 case INSERT:
11999 case INSTANTIABLE:
12000 case INTERVAL:
12001 case INVALIDATE:
12002 case ISOLATION:
12003 case JAVA:
12004 case LEVEL:
12005 case LIMIT:
12006 case LOCK:
12007 case LOOP:
12008 case MAP:
12009 case MAX:
12010 case MEMBER:
12011 case MERGE:
12012 case MIN:
12013 case MINUTE:
12014 case MLSLABEL:
12015 case MODIFY:
12016 case MOD:
12017 case MONTH:
12018 case NATURAL:
12019 case NEW:
12020 case NEW_DOT:
12021 case NO:
12022 case NONEDITIONABLE:
12023 case NOT:
12024 case NULL:
12025 case NULLIF:
12026 case OBJECT:
12027 case OID:
12028 case OPAQUE:
12029 case OPEN:
12030 case OPERATOR:
12031 case ORGANIZATION:
12032 case OTHERS:
12033 case OVERRIDING:
12034 case PACKAGE:
12035 case PARTITION:
12036 case PIPE:
12037 case PRAGMA:
12038 case PRESERVE:
12039 case PRIVATE:
12040 case PROCEDURE:
12041 case RAISE:
12042 case RANGE:
12043 case RAW:
12044 case REAL:
12045 case RECORD:
12046 case REF:
12047 case RELEASE:
12048 case RELIES_ON:
12049 case RENAME:
12050 case RESULT:
12051 case RETURN:
12052 case RETURNING:
12053 case REVERSE:
12054 case ROLLBACK:
12055 case ROW:
12056 case ROWS:
12057 case ROWID:
12058 case ROWNUM:
12059 case SAVE:
12060 case SAVEPOINT:
12061 case SECOND:
12062 case SELECT:
12063 case SELF:
12064 case SET:
12065 case SPACE:
12066 case SQL:
12067 case SQLCODE:
12068 case SQLERRM:
12069 case STATIC:
12070 case SUBTYPE:
12071 case SUBSTITUTABLE:
12072 case SUCCESSFUL:
12073 case SYSDATE:
12074 case SYS_REFCURSOR:
12075 case TEMPORARY:
12076 case TIME:
12077 case TIMESTAMP:
12078 case TIMEZONE_REGION:
12079 case TIMEZONE_ABBR:
12080 case TIMEZONE_MINUTE:
12081 case TIMEZONE_HOUR:
12082 case TRANSACTION:
12083 case TRUE:
12084 case TYPE:
12085 case UNDER:
12086 case USING:
12087 case WHILE:
12088 case YES:
12089 case SHOW:
12090 case A:
12091 case UPDATE:
12092 case DOUBLE:
12093 case DEC:
12094 case PRECISION:
12095 case INT:
12096 case NUMERIC:
12097 case NCHAR:
12098 case NVARCHAR2:
12099 case STRING:
12100 case UROWID:
12101 case VARRAY:
12102 case VARYING:
12103 case BFILE:
12104 case BLOB:
12105 case CLOB:
12106 case NCLOB:
12107 case YEAR:
12108 case LOCAL:
12109 case WITH:
12110 case ZONE:
12111 case CHARACTER:
12112 case AFTER:
12113 case BEFORE:
12114 case OLD:
12115 case PARENT:
12116 case CC_IF:
12117 case CC_ERROR:
12118 case ANALYZE:
12119 case ASSOCIATE:
12120 case AUDIT:
12121 case COMPOUND:
12122 case DATABASE:
12123 case CALL:
12124 case DDL:
12125 case DISASSOCIATE:
12126 case EACH:
12127 case FOLLOWS:
12128 case LOGOFF:
12129 case LOGON:
12130 case NESTED:
12131 case NOAUDIT:
12132 case SCHEMA:
12133 case SERVERERROR:
12134 case SHUTDOWN:
12135 case STARTUP:
12136 case STATEMENT:
12137 case STATISTICS:
12138 case SUSPEND:
12139 case TRUNCATE:
12140 case WRAPPED:
12141 case LIBRARY:
12142 case NAME:
12143 case STRUCT:
12144 case CONTEXT:
12145 case PARAMETERS:
12146 case LENGTH:
12147 case TDO:
12148 case MAXLEN:
12149 case CHARSETID:
12150 case CHARSETFORM:
12151 case ACCEPT:
12152 case ACCESSIBLE:
12153 case COPY:
12154 case DEFINE:
12155 case DISCONNECT:
12156 case HOST:
12157 case PRINT:
12158 case QUIT:
12159 case REMARK:
12160 case UNDEFINE:
12161 case VARIABLE:
12162 case WHENEVER:
12163 case ATTACH:
12164 case CAST:
12165 case TREAT:
12166 case TRIM:
12167 case LEFT:
12168 case RIGHT:
12169 case BOTH:
12170 case EMPTY:
12171 case MULTISET:
12172 case SUBMULTISET:
12173 case LEADING:
12174 case TRAILING:
12175 case CHAR_CS:
12176 case NCHAR_CS:
12177 case DBTIMEZONE:
12178 case SESSIONTIMEZONE:
12179 case AUTHENTICATED:
12180 case LINK:
12181 case SHARED:
12182 case DIRECTORY:
12183 case USER:
12184 case IDENTIFIER:
12185 case UNSIGNED_NUMERIC_LITERAL:
12186 case CHARACTER_LITERAL:
12187 case STRING_LITERAL:
12188 case QUOTED_LITERAL:
12189 ;
12190 break;
12191 default:
12192 jj_la1[137] = jj_gen;
12193 break label_31;
12194 }
12195 }
12196 jj_consume_token(END);
12197 jj_consume_token(LOOP);
12198 switch (jj_nt.kind) {
12199 case IDENTIFIER:
12200 jj_consume_token(IDENTIFIER);
12201 break;
12202 default:
12203 jj_la1[138] = jj_gen;
12204 ;
12205 }
12206 jjtree.closeNodeScope(jjtn000, true);
12207 jjtc000 = false;
12208 {if (true) return jjtn000 ;}
12209 } catch (Throwable jjte000) {
12210 if (jjtc000) {
12211 jjtree.clearNodeScope(jjtn000);
12212 jjtc000 = false;
12213 } else {
12214 jjtree.popNode();
12215 }
12216 if (jjte000 instanceof RuntimeException) {
12217 {if (true) throw (RuntimeException)jjte000;}
12218 }
12219 if (jjte000 instanceof ParseException) {
12220 {if (true) throw (ParseException)jjte000;}
12221 }
12222 {if (true) throw (Error)jjte000;}
12223 } finally {
12224 if (jjtc000) {
12225 jjtree.closeNodeScope(jjtn000, true);
12226 }
12227 }
12228 throw new Error("Missing return statement in function");
12229 }
12230
12231 final public ASTIfStatement IfStatement() throws ParseException {
12232
12233 ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
12234 boolean jjtc000 = true;
12235 jjtree.openNodeScope(jjtn000);
12236 try {
12237 jj_consume_token(IF);
12238 Expression();
12239 jj_consume_token(THEN);
12240 label_32:
12241 while (true) {
12242 Statement();
12243 switch (jj_nt.kind) {
12244 case 5:
12245 case 16:
12246 case 17:
12247 case 21:
12248 case REPLACE:
12249 case DEFINER:
12250 case CURRENT_USER:
12251 case LANGUAGE:
12252 case INLINE:
12253 case ADD:
12254 case AGGREGATE:
12255 case ARRAY:
12256 case AT:
12257 case ATTRIBUTE:
12258 case AUTHID:
12259 case BEGIN:
12260 case BODY:
12261 case BULK:
12262 case BYTE:
12263 case CASCADE:
12264 case CASE:
12265 case CLOSE:
12266 case COALESCE:
12267 case COLLECT:
12268 case COLUMN:
12269 case COMMENT:
12270 case COMMIT:
12271 case CONSTRUCTOR:
12272 case CONTINUE:
12273 case CONVERT:
12274 case CURRENT:
12275 case CURSOR:
12276 case DATA:
12277 case DATE:
12278 case DAY:
12279 case DECLARE:
12280 case DELETE:
12281 case DISABLE:
12282 case EDITIONABLE:
12283 case ELEMENT:
12284 case ENABLE:
12285 case ESCAPE:
12286 case EXCEPT:
12287 case EXCEPTIONS:
12288 case EXECUTE:
12289 case EXIT:
12290 case EXTERNAL:
12291 case EXTENDS:
12292 case EXTRACT:
12293 case FALSE:
12294 case FETCH:
12295 case FINAL:
12296 case FOR:
12297 case FORALL:
12298 case FORCE:
12299 case FUNCTION:
12300 case GLOBAL:
12301 case GOTO:
12302 case HASH:
12303 case HEAP:
12304 case HOUR:
12305 case IF:
12306 case IMMEDIATE:
12307 case INDICES:
12308 case INDEXTYPE:
12309 case INDICATOR:
12310 case INSERT:
12311 case INSTANTIABLE:
12312 case INTERVAL:
12313 case INVALIDATE:
12314 case ISOLATION:
12315 case JAVA:
12316 case LEVEL:
12317 case LIMIT:
12318 case LOCK:
12319 case LOOP:
12320 case MAP:
12321 case MAX:
12322 case MEMBER:
12323 case MERGE:
12324 case MIN:
12325 case MINUTE:
12326 case MLSLABEL:
12327 case MODIFY:
12328 case MOD:
12329 case MONTH:
12330 case NATURAL:
12331 case NEW:
12332 case NEW_DOT:
12333 case NO:
12334 case NONEDITIONABLE:
12335 case NOT:
12336 case NULL:
12337 case NULLIF:
12338 case OBJECT:
12339 case OID:
12340 case OPAQUE:
12341 case OPEN:
12342 case OPERATOR:
12343 case ORGANIZATION:
12344 case OTHERS:
12345 case OVERRIDING:
12346 case PACKAGE:
12347 case PARTITION:
12348 case PIPE:
12349 case PRAGMA:
12350 case PRESERVE:
12351 case PRIVATE:
12352 case PROCEDURE:
12353 case RAISE:
12354 case RANGE:
12355 case RAW:
12356 case REAL:
12357 case RECORD:
12358 case REF:
12359 case RELEASE:
12360 case RELIES_ON:
12361 case RENAME:
12362 case RESULT:
12363 case RETURN:
12364 case RETURNING:
12365 case REVERSE:
12366 case ROLLBACK:
12367 case ROW:
12368 case ROWS:
12369 case ROWID:
12370 case ROWNUM:
12371 case SAVE:
12372 case SAVEPOINT:
12373 case SECOND:
12374 case SELECT:
12375 case SELF:
12376 case SET:
12377 case SPACE:
12378 case SQL:
12379 case SQLCODE:
12380 case SQLERRM:
12381 case STATIC:
12382 case SUBTYPE:
12383 case SUBSTITUTABLE:
12384 case SUCCESSFUL:
12385 case SYSDATE:
12386 case SYS_REFCURSOR:
12387 case TEMPORARY:
12388 case TIME:
12389 case TIMESTAMP:
12390 case TIMEZONE_REGION:
12391 case TIMEZONE_ABBR:
12392 case TIMEZONE_MINUTE:
12393 case TIMEZONE_HOUR:
12394 case TRANSACTION:
12395 case TRUE:
12396 case TYPE:
12397 case UNDER:
12398 case USING:
12399 case WHILE:
12400 case YES:
12401 case SHOW:
12402 case A:
12403 case UPDATE:
12404 case DOUBLE:
12405 case DEC:
12406 case PRECISION:
12407 case INT:
12408 case NUMERIC:
12409 case NCHAR:
12410 case NVARCHAR2:
12411 case STRING:
12412 case UROWID:
12413 case VARRAY:
12414 case VARYING:
12415 case BFILE:
12416 case BLOB:
12417 case CLOB:
12418 case NCLOB:
12419 case YEAR:
12420 case LOCAL:
12421 case WITH:
12422 case ZONE:
12423 case CHARACTER:
12424 case AFTER:
12425 case BEFORE:
12426 case OLD:
12427 case PARENT:
12428 case CC_IF:
12429 case CC_ERROR:
12430 case ANALYZE:
12431 case ASSOCIATE:
12432 case AUDIT:
12433 case COMPOUND:
12434 case DATABASE:
12435 case CALL:
12436 case DDL:
12437 case DISASSOCIATE:
12438 case EACH:
12439 case FOLLOWS:
12440 case LOGOFF:
12441 case LOGON:
12442 case NESTED:
12443 case NOAUDIT:
12444 case SCHEMA:
12445 case SERVERERROR:
12446 case SHUTDOWN:
12447 case STARTUP:
12448 case STATEMENT:
12449 case STATISTICS:
12450 case SUSPEND:
12451 case TRUNCATE:
12452 case WRAPPED:
12453 case LIBRARY:
12454 case NAME:
12455 case STRUCT:
12456 case CONTEXT:
12457 case PARAMETERS:
12458 case LENGTH:
12459 case TDO:
12460 case MAXLEN:
12461 case CHARSETID:
12462 case CHARSETFORM:
12463 case ACCEPT:
12464 case ACCESSIBLE:
12465 case COPY:
12466 case DEFINE:
12467 case DISCONNECT:
12468 case HOST:
12469 case PRINT:
12470 case QUIT:
12471 case REMARK:
12472 case UNDEFINE:
12473 case VARIABLE:
12474 case WHENEVER:
12475 case ATTACH:
12476 case CAST:
12477 case TREAT:
12478 case TRIM:
12479 case LEFT:
12480 case RIGHT:
12481 case BOTH:
12482 case EMPTY:
12483 case MULTISET:
12484 case SUBMULTISET:
12485 case LEADING:
12486 case TRAILING:
12487 case CHAR_CS:
12488 case NCHAR_CS:
12489 case DBTIMEZONE:
12490 case SESSIONTIMEZONE:
12491 case AUTHENTICATED:
12492 case LINK:
12493 case SHARED:
12494 case DIRECTORY:
12495 case USER:
12496 case IDENTIFIER:
12497 case UNSIGNED_NUMERIC_LITERAL:
12498 case CHARACTER_LITERAL:
12499 case STRING_LITERAL:
12500 case QUOTED_LITERAL:
12501 ;
12502 break;
12503 default:
12504 jj_la1[139] = jj_gen;
12505 break label_32;
12506 }
12507 }
12508 label_33:
12509 while (true) {
12510 switch (jj_nt.kind) {
12511 case ELSIF:
12512 ;
12513 break;
12514 default:
12515 jj_la1[140] = jj_gen;
12516 break label_33;
12517 }
12518 ElsifClause();
12519 jjtn000.setHasElse();
12520 }
12521 switch (jj_nt.kind) {
12522 case ELSE:
12523 ElseClause();
12524 jjtn000.setHasElse();
12525 break;
12526 default:
12527 jj_la1[141] = jj_gen;
12528 ;
12529 }
12530 jj_consume_token(END);
12531 jj_consume_token(IF);
12532 jjtree.closeNodeScope(jjtn000, true);
12533 jjtc000 = false;
12534 {if (true) return jjtn000 ;}
12535 } catch (Throwable jjte000) {
12536 if (jjtc000) {
12537 jjtree.clearNodeScope(jjtn000);
12538 jjtc000 = false;
12539 } else {
12540 jjtree.popNode();
12541 }
12542 if (jjte000 instanceof RuntimeException) {
12543 {if (true) throw (RuntimeException)jjte000;}
12544 }
12545 if (jjte000 instanceof ParseException) {
12546 {if (true) throw (ParseException)jjte000;}
12547 }
12548 {if (true) throw (Error)jjte000;}
12549 } finally {
12550 if (jjtc000) {
12551 jjtree.closeNodeScope(jjtn000, true);
12552 }
12553 }
12554 throw new Error("Missing return statement in function");
12555 }
12556
12557
12558
12559
12560
12561 final public ASTForIndex ForIndex() throws ParseException {
12562
12563 ASTForIndex jjtn000 = new ASTForIndex(this, JJTFORINDEX);
12564 boolean jjtc000 = true;
12565 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
12566 try {
12567 simpleNode = ID();
12568 jjtree.closeNodeScope(jjtn000, true);
12569 jjtc000 = false;
12570 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
12571 } catch (Throwable jjte000) {
12572 if (jjtc000) {
12573 jjtree.clearNodeScope(jjtn000);
12574 jjtc000 = false;
12575 } else {
12576 jjtree.popNode();
12577 }
12578 if (jjte000 instanceof RuntimeException) {
12579 {if (true) throw (RuntimeException)jjte000;}
12580 }
12581 if (jjte000 instanceof ParseException) {
12582 {if (true) throw (ParseException)jjte000;}
12583 }
12584 {if (true) throw (Error)jjte000;}
12585 } finally {
12586 if (jjtc000) {
12587 jjtree.closeNodeScope(jjtn000, true);
12588 }
12589 }
12590 throw new Error("Missing return statement in function");
12591 }
12592
12593
12594
12595
12596 final public ASTForAllIndex ForAllIndex() throws ParseException {
12597
12598 ASTForAllIndex jjtn000 = new ASTForAllIndex(this, JJTFORALLINDEX);
12599 boolean jjtc000 = true;
12600 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
12601 try {
12602 simpleNode = ID();
12603 jjtree.closeNodeScope(jjtn000, true);
12604 jjtc000 = false;
12605 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
12606 } catch (Throwable jjte000) {
12607 if (jjtc000) {
12608 jjtree.clearNodeScope(jjtn000);
12609 jjtc000 = false;
12610 } else {
12611 jjtree.popNode();
12612 }
12613 if (jjte000 instanceof RuntimeException) {
12614 {if (true) throw (RuntimeException)jjte000;}
12615 }
12616 if (jjte000 instanceof ParseException) {
12617 {if (true) throw (ParseException)jjte000;}
12618 }
12619 {if (true) throw (Error)jjte000;}
12620 } finally {
12621 if (jjtc000) {
12622 jjtree.closeNodeScope(jjtn000, true);
12623 }
12624 }
12625 throw new Error("Missing return statement in function");
12626 }
12627
12628 final public ASTForAllStatement ForAllStatement() throws ParseException {
12629
12630 ASTForAllStatement jjtn000 = new ASTForAllStatement(this, JJTFORALLSTATEMENT);
12631 boolean jjtc000 = true;
12632 jjtree.openNodeScope(jjtn000);
12633 try {
12634 jj_consume_token(FORALL);
12635 ForAllIndex();
12636 jj_consume_token(IN);
12637 switch (jj_nt.kind) {
12638 case INDICES:
12639 case VALUES:
12640 switch (jj_nt.kind) {
12641 case INDICES:
12642 jj_consume_token(INDICES);
12643 break;
12644 case VALUES:
12645 jj_consume_token(VALUES);
12646 break;
12647 default:
12648 jj_la1[142] = jj_gen;
12649 jj_consume_token(-1);
12650 throw new ParseException();
12651 }
12652 jj_consume_token(OF);
12653 Expression();
12654 break;
12655 case 5:
12656 case 16:
12657 case 17:
12658 case REPLACE:
12659 case DEFINER:
12660 case CURRENT_USER:
12661 case LANGUAGE:
12662 case INLINE:
12663 case ADD:
12664 case AGGREGATE:
12665 case ARRAY:
12666 case AT:
12667 case ATTRIBUTE:
12668 case AUTHID:
12669 case BODY:
12670 case BULK:
12671 case BYTE:
12672 case CASCADE:
12673 case CASE:
12674 case CLOSE:
12675 case COALESCE:
12676 case COLLECT:
12677 case COLUMN:
12678 case COMMENT:
12679 case COMMIT:
12680 case CONSTRUCTOR:
12681 case CONTINUE:
12682 case CONVERT:
12683 case CURRENT:
12684 case CURSOR:
12685 case DATA:
12686 case DATE:
12687 case DAY:
12688 case DISABLE:
12689 case EDITIONABLE:
12690 case ELEMENT:
12691 case ENABLE:
12692 case ESCAPE:
12693 case EXCEPT:
12694 case EXCEPTIONS:
12695 case EXIT:
12696 case EXTERNAL:
12697 case EXTENDS:
12698 case EXTRACT:
12699 case FALSE:
12700 case FINAL:
12701 case FORCE:
12702 case FUNCTION:
12703 case GLOBAL:
12704 case HASH:
12705 case HEAP:
12706 case HOUR:
12707 case IMMEDIATE:
12708 case INDEXTYPE:
12709 case INDICATOR:
12710 case INSTANTIABLE:
12711 case INTERVAL:
12712 case INVALIDATE:
12713 case ISOLATION:
12714 case JAVA:
12715 case LEVEL:
12716 case LIMIT:
12717 case LOOP:
12718 case MAP:
12719 case MAX:
12720 case MEMBER:
12721 case MERGE:
12722 case MIN:
12723 case MINUTE:
12724 case MLSLABEL:
12725 case MODIFY:
12726 case MOD:
12727 case MONTH:
12728 case NATURAL:
12729 case NEW:
12730 case NEW_DOT:
12731 case NO:
12732 case NONEDITIONABLE:
12733 case NOT:
12734 case NULL:
12735 case NULLIF:
12736 case OBJECT:
12737 case OID:
12738 case OPAQUE:
12739 case OPEN:
12740 case OPERATOR:
12741 case ORGANIZATION:
12742 case OTHERS:
12743 case OVERRIDING:
12744 case PACKAGE:
12745 case PARTITION:
12746 case PRESERVE:
12747 case PRIVATE:
12748 case PROCEDURE:
12749 case RANGE:
12750 case RAW:
12751 case REAL:
12752 case RECORD:
12753 case REF:
12754 case RELEASE:
12755 case RELIES_ON:
12756 case RENAME:
12757 case RESULT:
12758 case RETURN:
12759 case RETURNING:
12760 case REVERSE:
12761 case ROLLBACK:
12762 case ROW:
12763 case ROWS:
12764 case ROWID:
12765 case ROWNUM:
12766 case SAVE:
12767 case SAVEPOINT:
12768 case SECOND:
12769 case SELECT:
12770 case SELF:
12771 case SET:
12772 case SPACE:
12773 case SQL:
12774 case SQLCODE:
12775 case SQLERRM:
12776 case STATIC:
12777 case SUBTYPE:
12778 case SUBSTITUTABLE:
12779 case SUCCESSFUL:
12780 case SYSDATE:
12781 case SYS_REFCURSOR:
12782 case TEMPORARY:
12783 case TIME:
12784 case TIMESTAMP:
12785 case TIMEZONE_REGION:
12786 case TIMEZONE_ABBR:
12787 case TIMEZONE_MINUTE:
12788 case TIMEZONE_HOUR:
12789 case TRANSACTION:
12790 case TRUE:
12791 case TYPE:
12792 case UNDER:
12793 case USING:
12794 case YES:
12795 case SHOW:
12796 case A:
12797 case DOUBLE:
12798 case DEC:
12799 case PRECISION:
12800 case INT:
12801 case NUMERIC:
12802 case NCHAR:
12803 case NVARCHAR2:
12804 case STRING:
12805 case UROWID:
12806 case VARRAY:
12807 case VARYING:
12808 case BFILE:
12809 case BLOB:
12810 case CLOB:
12811 case NCLOB:
12812 case YEAR:
12813 case LOCAL:
12814 case WITH:
12815 case ZONE:
12816 case CHARACTER:
12817 case AFTER:
12818 case BEFORE:
12819 case OLD:
12820 case PARENT:
12821 case CC_IF:
12822 case ANALYZE:
12823 case ASSOCIATE:
12824 case AUDIT:
12825 case COMPOUND:
12826 case DATABASE:
12827 case CALL:
12828 case DDL:
12829 case DISASSOCIATE:
12830 case EACH:
12831 case FOLLOWS:
12832 case LOGOFF:
12833 case LOGON:
12834 case NESTED:
12835 case NOAUDIT:
12836 case SCHEMA:
12837 case SERVERERROR:
12838 case SHUTDOWN:
12839 case STARTUP:
12840 case STATEMENT:
12841 case STATISTICS:
12842 case SUSPEND:
12843 case TRUNCATE:
12844 case WRAPPED:
12845 case LIBRARY:
12846 case NAME:
12847 case STRUCT:
12848 case CONTEXT:
12849 case PARAMETERS:
12850 case LENGTH:
12851 case TDO:
12852 case MAXLEN:
12853 case CHARSETID:
12854 case CHARSETFORM:
12855 case ACCEPT:
12856 case ACCESSIBLE:
12857 case COPY:
12858 case DEFINE:
12859 case DISCONNECT:
12860 case HOST:
12861 case PRINT:
12862 case QUIT:
12863 case REMARK:
12864 case UNDEFINE:
12865 case VARIABLE:
12866 case WHENEVER:
12867 case ATTACH:
12868 case CAST:
12869 case TREAT:
12870 case TRIM:
12871 case LEFT:
12872 case RIGHT:
12873 case BOTH:
12874 case EMPTY:
12875 case MULTISET:
12876 case SUBMULTISET:
12877 case LEADING:
12878 case TRAILING:
12879 case CHAR_CS:
12880 case NCHAR_CS:
12881 case DBTIMEZONE:
12882 case SESSIONTIMEZONE:
12883 case AUTHENTICATED:
12884 case LINK:
12885 case SHARED:
12886 case DIRECTORY:
12887 case USER:
12888 case IDENTIFIER:
12889 case UNSIGNED_NUMERIC_LITERAL:
12890 case CHARACTER_LITERAL:
12891 case STRING_LITERAL:
12892 case QUOTED_LITERAL:
12893 Expression();
12894 switch (jj_nt.kind) {
12895 case 12:
12896 jj_consume_token(12);
12897 Expression();
12898 break;
12899 default:
12900 jj_la1[143] = jj_gen;
12901 ;
12902 }
12903 break;
12904 default:
12905 jj_la1[144] = jj_gen;
12906 jj_consume_token(-1);
12907 throw new ParseException();
12908 }
12909 switch (jj_nt.kind) {
12910 case SAVE:
12911 jj_consume_token(SAVE);
12912 jj_consume_token(EXCEPTIONS);
12913 break;
12914 default:
12915 jj_la1[145] = jj_gen;
12916 ;
12917 }
12918 SqlStatement(null,";");
12919 jjtree.closeNodeScope(jjtn000, true);
12920 jjtc000 = false;
12921 {if (true) return jjtn000 ;}
12922 } catch (Throwable jjte000) {
12923 if (jjtc000) {
12924 jjtree.clearNodeScope(jjtn000);
12925 jjtc000 = false;
12926 } else {
12927 jjtree.popNode();
12928 }
12929 if (jjte000 instanceof RuntimeException) {
12930 {if (true) throw (RuntimeException)jjte000;}
12931 }
12932 if (jjte000 instanceof ParseException) {
12933 {if (true) throw (ParseException)jjte000;}
12934 }
12935 {if (true) throw (Error)jjte000;}
12936 } finally {
12937 if (jjtc000) {
12938 jjtree.closeNodeScope(jjtn000, true);
12939 }
12940 }
12941 throw new Error("Missing return statement in function");
12942 }
12943
12944 final public ASTGotoStatement GotoStatement() throws ParseException {
12945
12946 ASTGotoStatement jjtn000 = new ASTGotoStatement(this, JJTGOTOSTATEMENT);
12947 boolean jjtc000 = true;
12948 jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
12949 try {
12950 jj_consume_token(GOTO);
12951 label = QualifiedName();
12952 jjtree.closeNodeScope(jjtn000, true);
12953 jjtc000 = false;
12954 jjtn000.setImage(label.getImage()) ; {if (true) return jjtn000 ;}
12955 } catch (Throwable jjte000) {
12956 if (jjtc000) {
12957 jjtree.clearNodeScope(jjtn000);
12958 jjtc000 = false;
12959 } else {
12960 jjtree.popNode();
12961 }
12962 if (jjte000 instanceof RuntimeException) {
12963 {if (true) throw (RuntimeException)jjte000;}
12964 }
12965 if (jjte000 instanceof ParseException) {
12966 {if (true) throw (ParseException)jjte000;}
12967 }
12968 {if (true) throw (Error)jjte000;}
12969 } finally {
12970 if (jjtc000) {
12971 jjtree.closeNodeScope(jjtn000, true);
12972 }
12973 }
12974 throw new Error("Missing return statement in function");
12975 }
12976
12977 final public ASTReturnStatement ReturnStatement() throws ParseException {
12978
12979 ASTReturnStatement jjtn000 = new ASTReturnStatement(this, JJTRETURNSTATEMENT);
12980 boolean jjtc000 = true;
12981 jjtree.openNodeScope(jjtn000);
12982 try {
12983 jj_consume_token(RETURN);
12984 switch (jj_nt.kind) {
12985 case 5:
12986 case 16:
12987 case 17:
12988 case REPLACE:
12989 case DEFINER:
12990 case CURRENT_USER:
12991 case LANGUAGE:
12992 case INLINE:
12993 case ADD:
12994 case AGGREGATE:
12995 case ARRAY:
12996 case AT:
12997 case ATTRIBUTE:
12998 case AUTHID:
12999 case BODY:
13000 case BULK:
13001 case BYTE:
13002 case CASCADE:
13003 case CASE:
13004 case CLOSE:
13005 case COALESCE:
13006 case COLLECT:
13007 case COLUMN:
13008 case COMMENT:
13009 case COMMIT:
13010 case CONSTRUCTOR:
13011 case CONTINUE:
13012 case CONVERT:
13013 case CURRENT:
13014 case CURSOR:
13015 case DATA:
13016 case DATE:
13017 case DAY:
13018 case DISABLE:
13019 case EDITIONABLE:
13020 case ELEMENT:
13021 case ENABLE:
13022 case ESCAPE:
13023 case EXCEPT:
13024 case EXCEPTIONS:
13025 case EXIT:
13026 case EXTERNAL:
13027 case EXTENDS:
13028 case EXTRACT:
13029 case FALSE:
13030 case FINAL:
13031 case FORCE:
13032 case FUNCTION:
13033 case GLOBAL:
13034 case HASH:
13035 case HEAP:
13036 case HOUR:
13037 case IMMEDIATE:
13038 case INDICES:
13039 case INDEXTYPE:
13040 case INDICATOR:
13041 case INSTANTIABLE:
13042 case INTERVAL:
13043 case INVALIDATE:
13044 case ISOLATION:
13045 case JAVA:
13046 case LEVEL:
13047 case LIMIT:
13048 case LOOP:
13049 case MAP:
13050 case MAX:
13051 case MEMBER:
13052 case MERGE:
13053 case MIN:
13054 case MINUTE:
13055 case MLSLABEL:
13056 case MODIFY:
13057 case MOD:
13058 case MONTH:
13059 case NATURAL:
13060 case NEW:
13061 case NEW_DOT:
13062 case NO:
13063 case NONEDITIONABLE:
13064 case NOT:
13065 case NULL:
13066 case NULLIF:
13067 case OBJECT:
13068 case OID:
13069 case OPAQUE:
13070 case OPEN:
13071 case OPERATOR:
13072 case ORGANIZATION:
13073 case OTHERS:
13074 case OVERRIDING:
13075 case PACKAGE:
13076 case PARTITION:
13077 case PRESERVE:
13078 case PRIVATE:
13079 case PROCEDURE:
13080 case RANGE:
13081 case RAW:
13082 case REAL:
13083 case RECORD:
13084 case REF:
13085 case RELEASE:
13086 case RELIES_ON:
13087 case RENAME:
13088 case RESULT:
13089 case RETURN:
13090 case RETURNING:
13091 case REVERSE:
13092 case ROLLBACK:
13093 case ROW:
13094 case ROWS:
13095 case ROWID:
13096 case ROWNUM:
13097 case SAVE:
13098 case SAVEPOINT:
13099 case SECOND:
13100 case SELECT:
13101 case SELF:
13102 case SET:
13103 case SPACE:
13104 case SQL:
13105 case SQLCODE:
13106 case SQLERRM:
13107 case STATIC:
13108 case SUBTYPE:
13109 case SUBSTITUTABLE:
13110 case SUCCESSFUL:
13111 case SYSDATE:
13112 case SYS_REFCURSOR:
13113 case TEMPORARY:
13114 case TIME:
13115 case TIMESTAMP:
13116 case TIMEZONE_REGION:
13117 case TIMEZONE_ABBR:
13118 case TIMEZONE_MINUTE:
13119 case TIMEZONE_HOUR:
13120 case TRANSACTION:
13121 case TRUE:
13122 case TYPE:
13123 case UNDER:
13124 case USING:
13125 case YES:
13126 case SHOW:
13127 case A:
13128 case DOUBLE:
13129 case DEC:
13130 case PRECISION:
13131 case INT:
13132 case NUMERIC:
13133 case NCHAR:
13134 case NVARCHAR2:
13135 case STRING:
13136 case UROWID:
13137 case VARRAY:
13138 case VARYING:
13139 case BFILE:
13140 case BLOB:
13141 case CLOB:
13142 case NCLOB:
13143 case YEAR:
13144 case LOCAL:
13145 case WITH:
13146 case ZONE:
13147 case CHARACTER:
13148 case AFTER:
13149 case BEFORE:
13150 case OLD:
13151 case PARENT:
13152 case CC_IF:
13153 case ANALYZE:
13154 case ASSOCIATE:
13155 case AUDIT:
13156 case COMPOUND:
13157 case DATABASE:
13158 case CALL:
13159 case DDL:
13160 case DISASSOCIATE:
13161 case EACH:
13162 case FOLLOWS:
13163 case LOGOFF:
13164 case LOGON:
13165 case NESTED:
13166 case NOAUDIT:
13167 case SCHEMA:
13168 case SERVERERROR:
13169 case SHUTDOWN:
13170 case STARTUP:
13171 case STATEMENT:
13172 case STATISTICS:
13173 case SUSPEND:
13174 case TRUNCATE:
13175 case WRAPPED:
13176 case LIBRARY:
13177 case NAME:
13178 case STRUCT:
13179 case CONTEXT:
13180 case PARAMETERS:
13181 case LENGTH:
13182 case TDO:
13183 case MAXLEN:
13184 case CHARSETID:
13185 case CHARSETFORM:
13186 case ACCEPT:
13187 case ACCESSIBLE:
13188 case COPY:
13189 case DEFINE:
13190 case DISCONNECT:
13191 case HOST:
13192 case PRINT:
13193 case QUIT:
13194 case REMARK:
13195 case UNDEFINE:
13196 case VARIABLE:
13197 case WHENEVER:
13198 case ATTACH:
13199 case CAST:
13200 case TREAT:
13201 case TRIM:
13202 case LEFT:
13203 case RIGHT:
13204 case BOTH:
13205 case EMPTY:
13206 case MULTISET:
13207 case SUBMULTISET:
13208 case LEADING:
13209 case TRAILING:
13210 case CHAR_CS:
13211 case NCHAR_CS:
13212 case DBTIMEZONE:
13213 case SESSIONTIMEZONE:
13214 case AUTHENTICATED:
13215 case LINK:
13216 case SHARED:
13217 case DIRECTORY:
13218 case USER:
13219 case IDENTIFIER:
13220 case UNSIGNED_NUMERIC_LITERAL:
13221 case CHARACTER_LITERAL:
13222 case STRING_LITERAL:
13223 case QUOTED_LITERAL:
13224 Expression();
13225 break;
13226 default:
13227 jj_la1[146] = jj_gen;
13228 ;
13229 }
13230 jjtree.closeNodeScope(jjtn000, true);
13231 jjtc000 = false;
13232 {if (true) return jjtn000 ;}
13233 } catch (Throwable jjte000) {
13234 if (jjtc000) {
13235 jjtree.clearNodeScope(jjtn000);
13236 jjtc000 = false;
13237 } else {
13238 jjtree.popNode();
13239 }
13240 if (jjte000 instanceof RuntimeException) {
13241 {if (true) throw (RuntimeException)jjte000;}
13242 }
13243 if (jjte000 instanceof ParseException) {
13244 {if (true) throw (ParseException)jjte000;}
13245 }
13246 {if (true) throw (Error)jjte000;}
13247 } finally {
13248 if (jjtc000) {
13249 jjtree.closeNodeScope(jjtn000, true);
13250 }
13251 }
13252 throw new Error("Missing return statement in function");
13253 }
13254
13255 final public ASTContinueStatement ContinueStatement() throws ParseException {
13256
13257 ASTContinueStatement jjtn000 = new ASTContinueStatement(this, JJTCONTINUESTATEMENT);
13258 boolean jjtc000 = true;
13259 jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
13260 try {
13261 jj_consume_token(CONTINUE);
13262 switch (jj_nt.kind) {
13263 case REPLACE:
13264 case DEFINER:
13265 case CURRENT_USER:
13266 case LANGUAGE:
13267 case INLINE:
13268 case ADD:
13269 case AGGREGATE:
13270 case ARRAY:
13271 case AT:
13272 case ATTRIBUTE:
13273 case AUTHID:
13274 case BODY:
13275 case BULK:
13276 case BYTE:
13277 case CASCADE:
13278 case CLOSE:
13279 case COALESCE:
13280 case COLLECT:
13281 case COLUMN:
13282 case COMMENT:
13283 case COMMIT:
13284 case CONSTRUCTOR:
13285 case CONTINUE:
13286 case CONVERT:
13287 case CURRENT:
13288 case CURSOR:
13289 case DATA:
13290 case DAY:
13291 case DISABLE:
13292 case EDITIONABLE:
13293 case ELEMENT:
13294 case ENABLE:
13295 case ESCAPE:
13296 case EXCEPT:
13297 case EXCEPTIONS:
13298 case EXIT:
13299 case EXTERNAL:
13300 case EXTENDS:
13301 case EXTRACT:
13302 case FALSE:
13303 case FINAL:
13304 case FORCE:
13305 case FUNCTION:
13306 case GLOBAL:
13307 case HASH:
13308 case HEAP:
13309 case HOUR:
13310 case IMMEDIATE:
13311 case INDICES:
13312 case INDEXTYPE:
13313 case INDICATOR:
13314 case INSTANTIABLE:
13315 case INTERVAL:
13316 case INVALIDATE:
13317 case ISOLATION:
13318 case JAVA:
13319 case LEVEL:
13320 case LIMIT:
13321 case LOOP:
13322 case MAP:
13323 case MAX:
13324 case MEMBER:
13325 case MERGE:
13326 case MIN:
13327 case MINUTE:
13328 case MLSLABEL:
13329 case MODIFY:
13330 case MOD:
13331 case MONTH:
13332 case NATURAL:
13333 case NEW:
13334 case NO:
13335 case NONEDITIONABLE:
13336 case NULLIF:
13337 case OBJECT:
13338 case OID:
13339 case OPAQUE:
13340 case OPEN:
13341 case OPERATOR:
13342 case ORGANIZATION:
13343 case OTHERS:
13344 case OVERRIDING:
13345 case PACKAGE:
13346 case PARTITION:
13347 case PRESERVE:
13348 case PRIVATE:
13349 case PROCEDURE:
13350 case RANGE:
13351 case RAW:
13352 case REAL:
13353 case RECORD:
13354 case REF:
13355 case RELEASE:
13356 case RELIES_ON:
13357 case RENAME:
13358 case RESULT:
13359 case RETURN:
13360 case RETURNING:
13361 case REVERSE:
13362 case ROLLBACK:
13363 case ROW:
13364 case ROWS:
13365 case ROWID:
13366 case ROWNUM:
13367 case SAVE:
13368 case SAVEPOINT:
13369 case SECOND:
13370 case SELF:
13371 case SET:
13372 case SPACE:
13373 case SQL:
13374 case SQLCODE:
13375 case SQLERRM:
13376 case STATIC:
13377 case SUBTYPE:
13378 case SUBSTITUTABLE:
13379 case SUCCESSFUL:
13380 case SYSDATE:
13381 case SYS_REFCURSOR:
13382 case TEMPORARY:
13383 case TIME:
13384 case TIMESTAMP:
13385 case TIMEZONE_REGION:
13386 case TIMEZONE_ABBR:
13387 case TIMEZONE_MINUTE:
13388 case TIMEZONE_HOUR:
13389 case TRANSACTION:
13390 case TRUE:
13391 case TYPE:
13392 case UNDER:
13393 case USING:
13394 case YES:
13395 case SHOW:
13396 case A:
13397 case DOUBLE:
13398 case DEC:
13399 case PRECISION:
13400 case INT:
13401 case NUMERIC:
13402 case NCHAR:
13403 case NVARCHAR2:
13404 case STRING:
13405 case UROWID:
13406 case VARRAY:
13407 case VARYING:
13408 case BFILE:
13409 case BLOB:
13410 case CLOB:
13411 case NCLOB:
13412 case YEAR:
13413 case LOCAL:
13414 case ZONE:
13415 case CHARACTER:
13416 case AFTER:
13417 case BEFORE:
13418 case OLD:
13419 case PARENT:
13420 case ANALYZE:
13421 case ASSOCIATE:
13422 case AUDIT:
13423 case COMPOUND:
13424 case DATABASE:
13425 case CALL:
13426 case DDL:
13427 case DISASSOCIATE:
13428 case EACH:
13429 case FOLLOWS:
13430 case LOGOFF:
13431 case LOGON:
13432 case NESTED:
13433 case NOAUDIT:
13434 case SCHEMA:
13435 case SERVERERROR:
13436 case SHUTDOWN:
13437 case STARTUP:
13438 case STATEMENT:
13439 case STATISTICS:
13440 case SUSPEND:
13441 case TRUNCATE:
13442 case WRAPPED:
13443 case LIBRARY:
13444 case NAME:
13445 case STRUCT:
13446 case CONTEXT:
13447 case PARAMETERS:
13448 case LENGTH:
13449 case TDO:
13450 case MAXLEN:
13451 case CHARSETID:
13452 case CHARSETFORM:
13453 case ACCEPT:
13454 case ACCESSIBLE:
13455 case COPY:
13456 case DEFINE:
13457 case DISCONNECT:
13458 case HOST:
13459 case PRINT:
13460 case QUIT:
13461 case REMARK:
13462 case UNDEFINE:
13463 case VARIABLE:
13464 case WHENEVER:
13465 case ATTACH:
13466 case CAST:
13467 case TREAT:
13468 case TRIM:
13469 case LEFT:
13470 case RIGHT:
13471 case BOTH:
13472 case EMPTY:
13473 case MULTISET:
13474 case SUBMULTISET:
13475 case LEADING:
13476 case TRAILING:
13477 case CHAR_CS:
13478 case NCHAR_CS:
13479 case DBTIMEZONE:
13480 case SESSIONTIMEZONE:
13481 case AUTHENTICATED:
13482 case LINK:
13483 case SHARED:
13484 case DIRECTORY:
13485 case USER:
13486 case IDENTIFIER:
13487 case QUOTED_LITERAL:
13488 label = UnqualifiedID();
13489 break;
13490 default:
13491 jj_la1[147] = jj_gen;
13492 ;
13493 }
13494 switch (jj_nt.kind) {
13495 case WHEN:
13496 jj_consume_token(WHEN);
13497 Expression();
13498 break;
13499 default:
13500 jj_la1[148] = jj_gen;
13501 ;
13502 }
13503 jjtree.closeNodeScope(jjtn000, true);
13504 jjtc000 = false;
13505 if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
13506 } catch (Throwable jjte000) {
13507 if (jjtc000) {
13508 jjtree.clearNodeScope(jjtn000);
13509 jjtc000 = false;
13510 } else {
13511 jjtree.popNode();
13512 }
13513 if (jjte000 instanceof RuntimeException) {
13514 {if (true) throw (RuntimeException)jjte000;}
13515 }
13516 if (jjte000 instanceof ParseException) {
13517 {if (true) throw (ParseException)jjte000;}
13518 }
13519 {if (true) throw (Error)jjte000;}
13520 } finally {
13521 if (jjtc000) {
13522 jjtree.closeNodeScope(jjtn000, true);
13523 }
13524 }
13525 throw new Error("Missing return statement in function");
13526 }
13527
13528 final public ASTExitStatement ExitStatement() throws ParseException {
13529
13530 ASTExitStatement jjtn000 = new ASTExitStatement(this, JJTEXITSTATEMENT);
13531 boolean jjtc000 = true;
13532 jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
13533 try {
13534 jj_consume_token(EXIT);
13535 switch (jj_nt.kind) {
13536 case REPLACE:
13537 case DEFINER:
13538 case CURRENT_USER:
13539 case LANGUAGE:
13540 case INLINE:
13541 case ADD:
13542 case AGGREGATE:
13543 case ARRAY:
13544 case AT:
13545 case ATTRIBUTE:
13546 case AUTHID:
13547 case BODY:
13548 case BULK:
13549 case BYTE:
13550 case CASCADE:
13551 case CLOSE:
13552 case COALESCE:
13553 case COLLECT:
13554 case COLUMN:
13555 case COMMENT:
13556 case COMMIT:
13557 case CONSTRUCTOR:
13558 case CONTINUE:
13559 case CONVERT:
13560 case CURRENT:
13561 case CURSOR:
13562 case DATA:
13563 case DAY:
13564 case DISABLE:
13565 case EDITIONABLE:
13566 case ELEMENT:
13567 case ENABLE:
13568 case ESCAPE:
13569 case EXCEPT:
13570 case EXCEPTIONS:
13571 case EXIT:
13572 case EXTERNAL:
13573 case EXTENDS:
13574 case EXTRACT:
13575 case FALSE:
13576 case FINAL:
13577 case FORCE:
13578 case FUNCTION:
13579 case GLOBAL:
13580 case HASH:
13581 case HEAP:
13582 case HOUR:
13583 case IMMEDIATE:
13584 case INDICES:
13585 case INDEXTYPE:
13586 case INDICATOR:
13587 case INSTANTIABLE:
13588 case INTERVAL:
13589 case INVALIDATE:
13590 case ISOLATION:
13591 case JAVA:
13592 case LEVEL:
13593 case LIMIT:
13594 case LOOP:
13595 case MAP:
13596 case MAX:
13597 case MEMBER:
13598 case MERGE:
13599 case MIN:
13600 case MINUTE:
13601 case MLSLABEL:
13602 case MODIFY:
13603 case MOD:
13604 case MONTH:
13605 case NATURAL:
13606 case NEW:
13607 case NO:
13608 case NONEDITIONABLE:
13609 case NULLIF:
13610 case OBJECT:
13611 case OID:
13612 case OPAQUE:
13613 case OPEN:
13614 case OPERATOR:
13615 case ORGANIZATION:
13616 case OTHERS:
13617 case OVERRIDING:
13618 case PACKAGE:
13619 case PARTITION:
13620 case PRESERVE:
13621 case PRIVATE:
13622 case PROCEDURE:
13623 case RANGE:
13624 case RAW:
13625 case REAL:
13626 case RECORD:
13627 case REF:
13628 case RELEASE:
13629 case RELIES_ON:
13630 case RENAME:
13631 case RESULT:
13632 case RETURN:
13633 case RETURNING:
13634 case REVERSE:
13635 case ROLLBACK:
13636 case ROW:
13637 case ROWS:
13638 case ROWID:
13639 case ROWNUM:
13640 case SAVE:
13641 case SAVEPOINT:
13642 case SECOND:
13643 case SELF:
13644 case SET:
13645 case SPACE:
13646 case SQL:
13647 case SQLCODE:
13648 case SQLERRM:
13649 case STATIC:
13650 case SUBTYPE:
13651 case SUBSTITUTABLE:
13652 case SUCCESSFUL:
13653 case SYSDATE:
13654 case SYS_REFCURSOR:
13655 case TEMPORARY:
13656 case TIME:
13657 case TIMESTAMP:
13658 case TIMEZONE_REGION:
13659 case TIMEZONE_ABBR:
13660 case TIMEZONE_MINUTE:
13661 case TIMEZONE_HOUR:
13662 case TRANSACTION:
13663 case TRUE:
13664 case TYPE:
13665 case UNDER:
13666 case USING:
13667 case YES:
13668 case SHOW:
13669 case A:
13670 case DOUBLE:
13671 case DEC:
13672 case PRECISION:
13673 case INT:
13674 case NUMERIC:
13675 case NCHAR:
13676 case NVARCHAR2:
13677 case STRING:
13678 case UROWID:
13679 case VARRAY:
13680 case VARYING:
13681 case BFILE:
13682 case BLOB:
13683 case CLOB:
13684 case NCLOB:
13685 case YEAR:
13686 case LOCAL:
13687 case ZONE:
13688 case CHARACTER:
13689 case AFTER:
13690 case BEFORE:
13691 case OLD:
13692 case PARENT:
13693 case ANALYZE:
13694 case ASSOCIATE:
13695 case AUDIT:
13696 case COMPOUND:
13697 case DATABASE:
13698 case CALL:
13699 case DDL:
13700 case DISASSOCIATE:
13701 case EACH:
13702 case FOLLOWS:
13703 case LOGOFF:
13704 case LOGON:
13705 case NESTED:
13706 case NOAUDIT:
13707 case SCHEMA:
13708 case SERVERERROR:
13709 case SHUTDOWN:
13710 case STARTUP:
13711 case STATEMENT:
13712 case STATISTICS:
13713 case SUSPEND:
13714 case TRUNCATE:
13715 case WRAPPED:
13716 case LIBRARY:
13717 case NAME:
13718 case STRUCT:
13719 case CONTEXT:
13720 case PARAMETERS:
13721 case LENGTH:
13722 case TDO:
13723 case MAXLEN:
13724 case CHARSETID:
13725 case CHARSETFORM:
13726 case ACCEPT:
13727 case ACCESSIBLE:
13728 case COPY:
13729 case DEFINE:
13730 case DISCONNECT:
13731 case HOST:
13732 case PRINT:
13733 case QUIT:
13734 case REMARK:
13735 case UNDEFINE:
13736 case VARIABLE:
13737 case WHENEVER:
13738 case ATTACH:
13739 case CAST:
13740 case TREAT:
13741 case TRIM:
13742 case LEFT:
13743 case RIGHT:
13744 case BOTH:
13745 case EMPTY:
13746 case MULTISET:
13747 case SUBMULTISET:
13748 case LEADING:
13749 case TRAILING:
13750 case CHAR_CS:
13751 case NCHAR_CS:
13752 case DBTIMEZONE:
13753 case SESSIONTIMEZONE:
13754 case AUTHENTICATED:
13755 case LINK:
13756 case SHARED:
13757 case DIRECTORY:
13758 case USER:
13759 case IDENTIFIER:
13760 case QUOTED_LITERAL:
13761 label = UnqualifiedID();
13762 break;
13763 default:
13764 jj_la1[149] = jj_gen;
13765 ;
13766 }
13767 switch (jj_nt.kind) {
13768 case WHEN:
13769 jj_consume_token(WHEN);
13770 Expression();
13771 break;
13772 default:
13773 jj_la1[150] = jj_gen;
13774 ;
13775 }
13776 jjtree.closeNodeScope(jjtn000, true);
13777 jjtc000 = false;
13778 if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
13779 } catch (Throwable jjte000) {
13780 if (jjtc000) {
13781 jjtree.clearNodeScope(jjtn000);
13782 jjtc000 = false;
13783 } else {
13784 jjtree.popNode();
13785 }
13786 if (jjte000 instanceof RuntimeException) {
13787 {if (true) throw (RuntimeException)jjte000;}
13788 }
13789 if (jjte000 instanceof ParseException) {
13790 {if (true) throw (ParseException)jjte000;}
13791 }
13792 {if (true) throw (Error)jjte000;}
13793 } finally {
13794 if (jjtc000) {
13795 jjtree.closeNodeScope(jjtn000, true);
13796 }
13797 }
13798 throw new Error("Missing return statement in function");
13799 }
13800
13801 final public ASTRaiseStatement RaiseStatement() throws ParseException {
13802
13803 ASTRaiseStatement jjtn000 = new ASTRaiseStatement(this, JJTRAISESTATEMENT);
13804 boolean jjtc000 = true;
13805 jjtree.openNodeScope(jjtn000);PLSQLNode exception = null ;
13806 try {
13807 jj_consume_token(RAISE);
13808 switch (jj_nt.kind) {
13809 case REPLACE:
13810 case DEFINER:
13811 case CURRENT_USER:
13812 case LANGUAGE:
13813 case INLINE:
13814 case ADD:
13815 case AGGREGATE:
13816 case ARRAY:
13817 case AT:
13818 case ATTRIBUTE:
13819 case AUTHID:
13820 case BODY:
13821 case BULK:
13822 case BYTE:
13823 case CASCADE:
13824 case CLOSE:
13825 case COALESCE:
13826 case COLLECT:
13827 case COLUMN:
13828 case COMMENT:
13829 case COMMIT:
13830 case CONSTRUCTOR:
13831 case CONTINUE:
13832 case CONVERT:
13833 case CURRENT:
13834 case CURSOR:
13835 case DATA:
13836 case DAY:
13837 case DISABLE:
13838 case EDITIONABLE:
13839 case ELEMENT:
13840 case ENABLE:
13841 case ESCAPE:
13842 case EXCEPT:
13843 case EXCEPTIONS:
13844 case EXIT:
13845 case EXTERNAL:
13846 case EXTENDS:
13847 case EXTRACT:
13848 case FALSE:
13849 case FINAL:
13850 case FORCE:
13851 case FUNCTION:
13852 case GLOBAL:
13853 case HASH:
13854 case HEAP:
13855 case HOUR:
13856 case IMMEDIATE:
13857 case INDICES:
13858 case INDEXTYPE:
13859 case INDICATOR:
13860 case INSTANTIABLE:
13861 case INTERVAL:
13862 case INVALIDATE:
13863 case ISOLATION:
13864 case JAVA:
13865 case LEVEL:
13866 case LIMIT:
13867 case LOOP:
13868 case MAP:
13869 case MAX:
13870 case MEMBER:
13871 case MERGE:
13872 case MIN:
13873 case MINUTE:
13874 case MLSLABEL:
13875 case MODIFY:
13876 case MOD:
13877 case MONTH:
13878 case NATURAL:
13879 case NEW:
13880 case NO:
13881 case NONEDITIONABLE:
13882 case NULLIF:
13883 case OBJECT:
13884 case OID:
13885 case OPAQUE:
13886 case OPEN:
13887 case OPERATOR:
13888 case ORGANIZATION:
13889 case OTHERS:
13890 case OVERRIDING:
13891 case PACKAGE:
13892 case PARTITION:
13893 case PRESERVE:
13894 case PRIVATE:
13895 case PROCEDURE:
13896 case RANGE:
13897 case RAW:
13898 case REAL:
13899 case RECORD:
13900 case REF:
13901 case RELEASE:
13902 case RELIES_ON:
13903 case RENAME:
13904 case RESULT:
13905 case RETURN:
13906 case RETURNING:
13907 case REVERSE:
13908 case ROLLBACK:
13909 case ROW:
13910 case ROWS:
13911 case ROWID:
13912 case ROWNUM:
13913 case SAVE:
13914 case SAVEPOINT:
13915 case SECOND:
13916 case SELF:
13917 case SET:
13918 case SPACE:
13919 case SQL:
13920 case SQLCODE:
13921 case SQLERRM:
13922 case STATIC:
13923 case SUBTYPE:
13924 case SUBSTITUTABLE:
13925 case SUCCESSFUL:
13926 case SYSDATE:
13927 case SYS_REFCURSOR:
13928 case TEMPORARY:
13929 case TIME:
13930 case TIMESTAMP:
13931 case TIMEZONE_REGION:
13932 case TIMEZONE_ABBR:
13933 case TIMEZONE_MINUTE:
13934 case TIMEZONE_HOUR:
13935 case TRANSACTION:
13936 case TRUE:
13937 case TYPE:
13938 case UNDER:
13939 case USING:
13940 case YES:
13941 case SHOW:
13942 case A:
13943 case DOUBLE:
13944 case DEC:
13945 case PRECISION:
13946 case INT:
13947 case NUMERIC:
13948 case NCHAR:
13949 case NVARCHAR2:
13950 case STRING:
13951 case UROWID:
13952 case VARRAY:
13953 case VARYING:
13954 case BFILE:
13955 case BLOB:
13956 case CLOB:
13957 case NCLOB:
13958 case YEAR:
13959 case LOCAL:
13960 case ZONE:
13961 case CHARACTER:
13962 case AFTER:
13963 case BEFORE:
13964 case OLD:
13965 case PARENT:
13966 case ANALYZE:
13967 case ASSOCIATE:
13968 case AUDIT:
13969 case COMPOUND:
13970 case DATABASE:
13971 case CALL:
13972 case DDL:
13973 case DISASSOCIATE:
13974 case EACH:
13975 case FOLLOWS:
13976 case LOGOFF:
13977 case LOGON:
13978 case NESTED:
13979 case NOAUDIT:
13980 case SCHEMA:
13981 case SERVERERROR:
13982 case SHUTDOWN:
13983 case STARTUP:
13984 case STATEMENT:
13985 case STATISTICS:
13986 case SUSPEND:
13987 case TRUNCATE:
13988 case WRAPPED:
13989 case LIBRARY:
13990 case NAME:
13991 case STRUCT:
13992 case CONTEXT:
13993 case PARAMETERS:
13994 case LENGTH:
13995 case TDO:
13996 case MAXLEN:
13997 case CHARSETID:
13998 case CHARSETFORM:
13999 case ACCEPT:
14000 case ACCESSIBLE:
14001 case COPY:
14002 case DEFINE:
14003 case DISCONNECT:
14004 case HOST:
14005 case PRINT:
14006 case QUIT:
14007 case REMARK:
14008 case UNDEFINE:
14009 case VARIABLE:
14010 case WHENEVER:
14011 case ATTACH:
14012 case CAST:
14013 case TREAT:
14014 case TRIM:
14015 case LEFT:
14016 case RIGHT:
14017 case BOTH:
14018 case EMPTY:
14019 case MULTISET:
14020 case SUBMULTISET:
14021 case LEADING:
14022 case TRAILING:
14023 case CHAR_CS:
14024 case NCHAR_CS:
14025 case DBTIMEZONE:
14026 case SESSIONTIMEZONE:
14027 case AUTHENTICATED:
14028 case LINK:
14029 case SHARED:
14030 case DIRECTORY:
14031 case USER:
14032 case IDENTIFIER:
14033 case QUOTED_LITERAL:
14034 exception = QualifiedName();
14035 break;
14036 default:
14037 jj_la1[151] = jj_gen;
14038 ;
14039 }
14040 jjtree.closeNodeScope(jjtn000, true);
14041 jjtc000 = false;
14042 if (null != exception) { jjtn000.setImage(exception.getImage()) ; } {if (true) return jjtn000 ;}
14043 } catch (Throwable jjte000) {
14044 if (jjtc000) {
14045 jjtree.clearNodeScope(jjtn000);
14046 jjtc000 = false;
14047 } else {
14048 jjtree.popNode();
14049 }
14050 if (jjte000 instanceof RuntimeException) {
14051 {if (true) throw (RuntimeException)jjte000;}
14052 }
14053 if (jjte000 instanceof ParseException) {
14054 {if (true) throw (ParseException)jjte000;}
14055 }
14056 {if (true) throw (Error)jjte000;}
14057 } finally {
14058 if (jjtc000) {
14059 jjtree.closeNodeScope(jjtn000, true);
14060 }
14061 }
14062 throw new Error("Missing return statement in function");
14063 }
14064
14065 final public ASTCloseStatement CloseStatement() throws ParseException {
14066
14067 ASTCloseStatement jjtn000 = new ASTCloseStatement(this, JJTCLOSESTATEMENT);
14068 boolean jjtc000 = true;
14069 jjtree.openNodeScope(jjtn000);PLSQLNode cursor = null ;
14070 try {
14071 jj_consume_token(CLOSE);
14072 cursor = QualifiedName();
14073 jjtree.closeNodeScope(jjtn000, true);
14074 jjtc000 = false;
14075 jjtn000.setImage(cursor.getImage()) ; {if (true) return jjtn000 ;}
14076 } catch (Throwable jjte000) {
14077 if (jjtc000) {
14078 jjtree.clearNodeScope(jjtn000);
14079 jjtc000 = false;
14080 } else {
14081 jjtree.popNode();
14082 }
14083 if (jjte000 instanceof RuntimeException) {
14084 {if (true) throw (RuntimeException)jjte000;}
14085 }
14086 if (jjte000 instanceof ParseException) {
14087 {if (true) throw (ParseException)jjte000;}
14088 }
14089 {if (true) throw (Error)jjte000;}
14090 } finally {
14091 if (jjtc000) {
14092 jjtree.closeNodeScope(jjtn000, true);
14093 }
14094 }
14095 throw new Error("Missing return statement in function");
14096 }
14097
14098 final public ASTOpenStatement OpenStatement() throws ParseException {
14099
14100 ASTOpenStatement jjtn000 = new ASTOpenStatement(this, JJTOPENSTATEMENT);
14101 boolean jjtc000 = true;
14102 jjtree.openNodeScope(jjtn000);
14103 try {
14104 jj_consume_token(OPEN);
14105 switch (jj_nt.kind) {
14106 case 5:
14107 case 16:
14108 case 17:
14109 case REPLACE:
14110 case DEFINER:
14111 case CURRENT_USER:
14112 case LANGUAGE:
14113 case INLINE:
14114 case ADD:
14115 case AGGREGATE:
14116 case ARRAY:
14117 case AT:
14118 case ATTRIBUTE:
14119 case AUTHID:
14120 case BODY:
14121 case BULK:
14122 case BYTE:
14123 case CASCADE:
14124 case CASE:
14125 case CLOSE:
14126 case COALESCE:
14127 case COLLECT:
14128 case COLUMN:
14129 case COMMENT:
14130 case COMMIT:
14131 case CONSTRUCTOR:
14132 case CONTINUE:
14133 case CONVERT:
14134 case CURRENT:
14135 case CURSOR:
14136 case DATA:
14137 case DATE:
14138 case DAY:
14139 case DISABLE:
14140 case EDITIONABLE:
14141 case ELEMENT:
14142 case ENABLE:
14143 case ESCAPE:
14144 case EXCEPT:
14145 case EXCEPTIONS:
14146 case EXIT:
14147 case EXTERNAL:
14148 case EXTENDS:
14149 case EXTRACT:
14150 case FALSE:
14151 case FINAL:
14152 case FORCE:
14153 case FUNCTION:
14154 case GLOBAL:
14155 case HASH:
14156 case HEAP:
14157 case HOUR:
14158 case IMMEDIATE:
14159 case INDICES:
14160 case INDEXTYPE:
14161 case INDICATOR:
14162 case INSTANTIABLE:
14163 case INTERVAL:
14164 case INVALIDATE:
14165 case ISOLATION:
14166 case JAVA:
14167 case LEVEL:
14168 case LIMIT:
14169 case LOOP:
14170 case MAP:
14171 case MAX:
14172 case MEMBER:
14173 case MERGE:
14174 case MIN:
14175 case MINUTE:
14176 case MLSLABEL:
14177 case MODIFY:
14178 case MOD:
14179 case MONTH:
14180 case NATURAL:
14181 case NEW:
14182 case NEW_DOT:
14183 case NO:
14184 case NONEDITIONABLE:
14185 case NOT:
14186 case NULL:
14187 case NULLIF:
14188 case OBJECT:
14189 case OID:
14190 case OPAQUE:
14191 case OPEN:
14192 case OPERATOR:
14193 case ORGANIZATION:
14194 case OTHERS:
14195 case OVERRIDING:
14196 case PACKAGE:
14197 case PARTITION:
14198 case PRESERVE:
14199 case PRIVATE:
14200 case PROCEDURE:
14201 case RANGE:
14202 case RAW:
14203 case REAL:
14204 case RECORD:
14205 case REF:
14206 case RELEASE:
14207 case RELIES_ON:
14208 case RENAME:
14209 case RESULT:
14210 case RETURN:
14211 case RETURNING:
14212 case REVERSE:
14213 case ROLLBACK:
14214 case ROW:
14215 case ROWS:
14216 case ROWID:
14217 case ROWNUM:
14218 case SAVE:
14219 case SAVEPOINT:
14220 case SECOND:
14221 case SELECT:
14222 case SELF:
14223 case SET:
14224 case SPACE:
14225 case SQL:
14226 case SQLCODE:
14227 case SQLERRM:
14228 case STATIC:
14229 case SUBTYPE:
14230 case SUBSTITUTABLE:
14231 case SUCCESSFUL:
14232 case SYSDATE:
14233 case SYS_REFCURSOR:
14234 case TEMPORARY:
14235 case TIME:
14236 case TIMESTAMP:
14237 case TIMEZONE_REGION:
14238 case TIMEZONE_ABBR:
14239 case TIMEZONE_MINUTE:
14240 case TIMEZONE_HOUR:
14241 case TRANSACTION:
14242 case TRUE:
14243 case TYPE:
14244 case UNDER:
14245 case USING:
14246 case YES:
14247 case SHOW:
14248 case A:
14249 case DOUBLE:
14250 case DEC:
14251 case PRECISION:
14252 case INT:
14253 case NUMERIC:
14254 case NCHAR:
14255 case NVARCHAR2:
14256 case STRING:
14257 case UROWID:
14258 case VARRAY:
14259 case VARYING:
14260 case BFILE:
14261 case BLOB:
14262 case CLOB:
14263 case NCLOB:
14264 case YEAR:
14265 case LOCAL:
14266 case WITH:
14267 case ZONE:
14268 case CHARACTER:
14269 case AFTER:
14270 case BEFORE:
14271 case OLD:
14272 case PARENT:
14273 case CC_IF:
14274 case ANALYZE:
14275 case ASSOCIATE:
14276 case AUDIT:
14277 case COMPOUND:
14278 case DATABASE:
14279 case CALL:
14280 case DDL:
14281 case DISASSOCIATE:
14282 case EACH:
14283 case FOLLOWS:
14284 case LOGOFF:
14285 case LOGON:
14286 case NESTED:
14287 case NOAUDIT:
14288 case SCHEMA:
14289 case SERVERERROR:
14290 case SHUTDOWN:
14291 case STARTUP:
14292 case STATEMENT:
14293 case STATISTICS:
14294 case SUSPEND:
14295 case TRUNCATE:
14296 case WRAPPED:
14297 case LIBRARY:
14298 case NAME:
14299 case STRUCT:
14300 case CONTEXT:
14301 case PARAMETERS:
14302 case LENGTH:
14303 case TDO:
14304 case MAXLEN:
14305 case CHARSETID:
14306 case CHARSETFORM:
14307 case ACCEPT:
14308 case ACCESSIBLE:
14309 case COPY:
14310 case DEFINE:
14311 case DISCONNECT:
14312 case HOST:
14313 case PRINT:
14314 case QUIT:
14315 case REMARK:
14316 case UNDEFINE:
14317 case VARIABLE:
14318 case WHENEVER:
14319 case ATTACH:
14320 case CAST:
14321 case TREAT:
14322 case TRIM:
14323 case LEFT:
14324 case RIGHT:
14325 case BOTH:
14326 case EMPTY:
14327 case MULTISET:
14328 case SUBMULTISET:
14329 case LEADING:
14330 case TRAILING:
14331 case CHAR_CS:
14332 case NCHAR_CS:
14333 case DBTIMEZONE:
14334 case SESSIONTIMEZONE:
14335 case AUTHENTICATED:
14336 case LINK:
14337 case SHARED:
14338 case DIRECTORY:
14339 case USER:
14340 case IDENTIFIER:
14341 case UNSIGNED_NUMERIC_LITERAL:
14342 case CHARACTER_LITERAL:
14343 case STRING_LITERAL:
14344 case QUOTED_LITERAL:
14345 Expression();
14346 break;
14347 default:
14348 jj_la1[152] = jj_gen;
14349 ;
14350 }
14351 switch (jj_nt.kind) {
14352 case FOR:
14353 jj_consume_token(FOR);
14354 Expression();
14355 switch (jj_nt.kind) {
14356 case USING:
14357 jj_consume_token(USING);
14358 switch (jj_nt.kind) {
14359 case IN:
14360 case IN_OUT:
14361 case OUT:
14362 switch (jj_nt.kind) {
14363 case IN:
14364 jj_consume_token(IN);
14365 break;
14366 case OUT:
14367 jj_consume_token(OUT);
14368 break;
14369 case IN_OUT:
14370 jj_consume_token(IN_OUT);
14371 break;
14372 default:
14373 jj_la1[153] = jj_gen;
14374 jj_consume_token(-1);
14375 throw new ParseException();
14376 }
14377 break;
14378 default:
14379 jj_la1[154] = jj_gen;
14380 ;
14381 }
14382 Expression();
14383 label_34:
14384 while (true) {
14385 switch (jj_nt.kind) {
14386 case 6:
14387 ;
14388 break;
14389 default:
14390 jj_la1[155] = jj_gen;
14391 break label_34;
14392 }
14393 jj_consume_token(6);
14394 switch (jj_nt.kind) {
14395 case IN:
14396 case IN_OUT:
14397 case OUT:
14398 switch (jj_nt.kind) {
14399 case IN:
14400 jj_consume_token(IN);
14401 break;
14402 case OUT:
14403 jj_consume_token(OUT);
14404 break;
14405 case IN_OUT:
14406 jj_consume_token(IN_OUT);
14407 break;
14408 default:
14409 jj_la1[156] = jj_gen;
14410 jj_consume_token(-1);
14411 throw new ParseException();
14412 }
14413 break;
14414 default:
14415 jj_la1[157] = jj_gen;
14416 ;
14417 }
14418 Expression();
14419 }
14420 break;
14421 default:
14422 jj_la1[158] = jj_gen;
14423 ;
14424 }
14425 break;
14426 default:
14427 jj_la1[159] = jj_gen;
14428 ;
14429 }
14430 jjtree.closeNodeScope(jjtn000, true);
14431 jjtc000 = false;
14432 {if (true) return jjtn000 ;}
14433 } catch (Throwable jjte000) {
14434 if (jjtc000) {
14435 jjtree.clearNodeScope(jjtn000);
14436 jjtc000 = false;
14437 } else {
14438 jjtree.popNode();
14439 }
14440 if (jjte000 instanceof RuntimeException) {
14441 {if (true) throw (RuntimeException)jjte000;}
14442 }
14443 if (jjte000 instanceof ParseException) {
14444 {if (true) throw (ParseException)jjte000;}
14445 }
14446 {if (true) throw (Error)jjte000;}
14447 } finally {
14448 if (jjtc000) {
14449 jjtree.closeNodeScope(jjtn000, true);
14450 }
14451 }
14452 throw new Error("Missing return statement in function");
14453 }
14454
14455 final public ASTFetchStatement FetchStatement() throws ParseException {
14456
14457 ASTFetchStatement jjtn000 = new ASTFetchStatement(this, JJTFETCHSTATEMENT);
14458 boolean jjtc000 = true;
14459 jjtree.openNodeScope(jjtn000);
14460 try {
14461 jj_consume_token(FETCH);
14462 QualifiedName();
14463 switch (jj_nt.kind) {
14464 case BULK:
14465 jj_consume_token(BULK);
14466 jj_consume_token(COLLECT);
14467 break;
14468 default:
14469 jj_la1[160] = jj_gen;
14470 ;
14471 }
14472 jj_consume_token(INTO);
14473 Expression();
14474 label_35:
14475 while (true) {
14476 switch (jj_nt.kind) {
14477 case 6:
14478 ;
14479 break;
14480 default:
14481 jj_la1[161] = jj_gen;
14482 break label_35;
14483 }
14484 jj_consume_token(6);
14485 Expression();
14486 }
14487 switch (jj_nt.kind) {
14488 case LIMIT:
14489 jj_consume_token(LIMIT);
14490 Expression();
14491 break;
14492 default:
14493 jj_la1[162] = jj_gen;
14494 ;
14495 }
14496 jjtree.closeNodeScope(jjtn000, true);
14497 jjtc000 = false;
14498 {if (true) return jjtn000 ;}
14499 } catch (Throwable jjte000) {
14500 if (jjtc000) {
14501 jjtree.clearNodeScope(jjtn000);
14502 jjtc000 = false;
14503 } else {
14504 jjtree.popNode();
14505 }
14506 if (jjte000 instanceof RuntimeException) {
14507 {if (true) throw (RuntimeException)jjte000;}
14508 }
14509 if (jjte000 instanceof ParseException) {
14510 {if (true) throw (ParseException)jjte000;}
14511 }
14512 {if (true) throw (Error)jjte000;}
14513 } finally {
14514 if (jjtc000) {
14515 jjtree.closeNodeScope(jjtn000, true);
14516 }
14517 }
14518 throw new Error("Missing return statement in function");
14519 }
14520
14521 final public ASTEmbeddedSqlStatement EmbeddedSqlStatement() throws ParseException {
14522
14523 ASTEmbeddedSqlStatement jjtn000 = new ASTEmbeddedSqlStatement(this, JJTEMBEDDEDSQLSTATEMENT);
14524 boolean jjtc000 = true;
14525 jjtree.openNodeScope(jjtn000);
14526 try {
14527 jj_consume_token(EXECUTE);
14528 jj_consume_token(IMMEDIATE);
14529 Expression();
14530 switch (jj_nt.kind) {
14531 case INTO:
14532 jj_consume_token(INTO);
14533 Name();
14534 label_36:
14535 while (true) {
14536 switch (jj_nt.kind) {
14537 case 6:
14538 ;
14539 break;
14540 default:
14541 jj_la1[163] = jj_gen;
14542 break label_36;
14543 }
14544 jj_consume_token(6);
14545 Name();
14546 }
14547 break;
14548 default:
14549 jj_la1[164] = jj_gen;
14550 ;
14551 }
14552 switch (jj_nt.kind) {
14553 case USING:
14554 jj_consume_token(USING);
14555 switch (jj_nt.kind) {
14556 case IN:
14557 case OUT:
14558 switch (jj_nt.kind) {
14559 case IN:
14560 jj_consume_token(IN);
14561 switch (jj_nt.kind) {
14562 case OUT:
14563 jj_consume_token(OUT);
14564 break;
14565 default:
14566 jj_la1[165] = jj_gen;
14567 ;
14568 }
14569 break;
14570 case OUT:
14571 jj_consume_token(OUT);
14572 break;
14573 default:
14574 jj_la1[166] = jj_gen;
14575 jj_consume_token(-1);
14576 throw new ParseException();
14577 }
14578 break;
14579 default:
14580 jj_la1[167] = jj_gen;
14581 ;
14582 }
14583 Expression();
14584 label_37:
14585 while (true) {
14586 switch (jj_nt.kind) {
14587 case 6:
14588 ;
14589 break;
14590 default:
14591 jj_la1[168] = jj_gen;
14592 break label_37;
14593 }
14594 jj_consume_token(6);
14595 switch (jj_nt.kind) {
14596 case IN:
14597 case OUT:
14598 switch (jj_nt.kind) {
14599 case IN:
14600 jj_consume_token(IN);
14601 switch (jj_nt.kind) {
14602 case OUT:
14603 jj_consume_token(OUT);
14604 break;
14605 default:
14606 jj_la1[169] = jj_gen;
14607 ;
14608 }
14609 break;
14610 case OUT:
14611 jj_consume_token(OUT);
14612 break;
14613 default:
14614 jj_la1[170] = jj_gen;
14615 jj_consume_token(-1);
14616 throw new ParseException();
14617 }
14618 break;
14619 default:
14620 jj_la1[171] = jj_gen;
14621 ;
14622 }
14623 Expression();
14624 }
14625 break;
14626 default:
14627 jj_la1[172] = jj_gen;
14628 ;
14629 }
14630 switch (jj_nt.kind) {
14631 case RETURN:
14632 case RETURNING:
14633 switch (jj_nt.kind) {
14634 case RETURN:
14635 jj_consume_token(RETURN);
14636 break;
14637 case RETURNING:
14638 jj_consume_token(RETURNING);
14639 break;
14640 default:
14641 jj_la1[173] = jj_gen;
14642 jj_consume_token(-1);
14643 throw new ParseException();
14644 }
14645 jj_consume_token(INTO);
14646 Expression();
14647 label_38:
14648 while (true) {
14649 switch (jj_nt.kind) {
14650 case 6:
14651 ;
14652 break;
14653 default:
14654 jj_la1[174] = jj_gen;
14655 break label_38;
14656 }
14657 jj_consume_token(6);
14658 Expression();
14659 }
14660 break;
14661 default:
14662 jj_la1[175] = jj_gen;
14663 ;
14664 }
14665 jj_consume_token(4);
14666 jjtree.closeNodeScope(jjtn000, true);
14667 jjtc000 = false;
14668 {if (true) return jjtn000 ;}
14669 } catch (Throwable jjte000) {
14670 if (jjtc000) {
14671 jjtree.clearNodeScope(jjtn000);
14672 jjtc000 = false;
14673 } else {
14674 jjtree.popNode();
14675 }
14676 if (jjte000 instanceof RuntimeException) {
14677 {if (true) throw (RuntimeException)jjte000;}
14678 }
14679 if (jjte000 instanceof ParseException) {
14680 {if (true) throw (ParseException)jjte000;}
14681 }
14682 {if (true) throw (Error)jjte000;}
14683 } finally {
14684 if (jjtc000) {
14685 jjtree.closeNodeScope(jjtn000, true);
14686 }
14687 }
14688 throw new Error("Missing return statement in function");
14689 }
14690
14691 final public ASTPipelineStatement PipelineStatement() throws ParseException {
14692
14693 ASTPipelineStatement jjtn000 = new ASTPipelineStatement(this, JJTPIPELINESTATEMENT);
14694 boolean jjtc000 = true;
14695 jjtree.openNodeScope(jjtn000);
14696 try {
14697 jj_consume_token(PIPE);
14698 jj_consume_token(ROW);
14699 Expression();
14700 jjtree.closeNodeScope(jjtn000, true);
14701 jjtc000 = false;
14702 {if (true) return jjtn000 ;}
14703 } catch (Throwable jjte000) {
14704 if (jjtc000) {
14705 jjtree.clearNodeScope(jjtn000);
14706 jjtc000 = false;
14707 } else {
14708 jjtree.popNode();
14709 }
14710 if (jjte000 instanceof RuntimeException) {
14711 {if (true) throw (RuntimeException)jjte000;}
14712 }
14713 if (jjte000 instanceof ParseException) {
14714 {if (true) throw (ParseException)jjte000;}
14715 }
14716 {if (true) throw (Error)jjte000;}
14717 } finally {
14718 if (jjtc000) {
14719 jjtree.closeNodeScope(jjtn000, true);
14720 }
14721 }
14722 throw new Error("Missing return statement in function");
14723 }
14724
14725 final public ASTConditionalCompilationStatement ConditionalCompilationStatement() throws ParseException {
14726
14727 ASTConditionalCompilationStatement jjtn000 = new ASTConditionalCompilationStatement(this, JJTCONDITIONALCOMPILATIONSTATEMENT);
14728 boolean jjtc000 = true;
14729 jjtree.openNodeScope(jjtn000);
14730 try {
14731 switch (jj_nt.kind) {
14732 case CC_IF:
14733 jj_consume_token(CC_IF);
14734 ConditionalOrExpression();
14735 jj_consume_token(CC_THEN);
14736 label_39:
14737 while (true) {
14738 switch (jj_nt.kind) {
14739 case 5:
14740 case 16:
14741 case 17:
14742 case 21:
14743 case REPLACE:
14744 case DEFINER:
14745 case CURRENT_USER:
14746 case LANGUAGE:
14747 case INLINE:
14748 case ADD:
14749 case AGGREGATE:
14750 case ARRAY:
14751 case AT:
14752 case ATTRIBUTE:
14753 case AUTHID:
14754 case BEGIN:
14755 case BODY:
14756 case BULK:
14757 case BYTE:
14758 case CASCADE:
14759 case CASE:
14760 case CLOSE:
14761 case COALESCE:
14762 case COLLECT:
14763 case COLUMN:
14764 case COMMENT:
14765 case COMMIT:
14766 case CONSTRUCTOR:
14767 case CONTINUE:
14768 case CONVERT:
14769 case CURRENT:
14770 case CURSOR:
14771 case DATA:
14772 case DATE:
14773 case DAY:
14774 case DECLARE:
14775 case DELETE:
14776 case DISABLE:
14777 case EDITIONABLE:
14778 case ELEMENT:
14779 case ENABLE:
14780 case ESCAPE:
14781 case EXCEPT:
14782 case EXCEPTIONS:
14783 case EXECUTE:
14784 case EXIT:
14785 case EXTERNAL:
14786 case EXTENDS:
14787 case EXTRACT:
14788 case FALSE:
14789 case FETCH:
14790 case FINAL:
14791 case FOR:
14792 case FORALL:
14793 case FORCE:
14794 case FUNCTION:
14795 case GLOBAL:
14796 case GOTO:
14797 case HASH:
14798 case HEAP:
14799 case HOUR:
14800 case IF:
14801 case IMMEDIATE:
14802 case INDICES:
14803 case INDEXTYPE:
14804 case INDICATOR:
14805 case INSERT:
14806 case INSTANTIABLE:
14807 case INTERVAL:
14808 case INVALIDATE:
14809 case ISOLATION:
14810 case JAVA:
14811 case LEVEL:
14812 case LIMIT:
14813 case LOCK:
14814 case LOOP:
14815 case MAP:
14816 case MAX:
14817 case MEMBER:
14818 case MERGE:
14819 case MIN:
14820 case MINUTE:
14821 case MLSLABEL:
14822 case MODIFY:
14823 case MOD:
14824 case MONTH:
14825 case NATURAL:
14826 case NEW:
14827 case NEW_DOT:
14828 case NO:
14829 case NONEDITIONABLE:
14830 case NOT:
14831 case NULL:
14832 case NULLIF:
14833 case OBJECT:
14834 case OID:
14835 case OPAQUE:
14836 case OPEN:
14837 case OPERATOR:
14838 case ORGANIZATION:
14839 case OTHERS:
14840 case OVERRIDING:
14841 case PACKAGE:
14842 case PARTITION:
14843 case PIPE:
14844 case PRAGMA:
14845 case PRESERVE:
14846 case PRIVATE:
14847 case PROCEDURE:
14848 case RAISE:
14849 case RANGE:
14850 case RAW:
14851 case REAL:
14852 case RECORD:
14853 case REF:
14854 case RELEASE:
14855 case RELIES_ON:
14856 case RENAME:
14857 case RESULT:
14858 case RETURN:
14859 case RETURNING:
14860 case REVERSE:
14861 case ROLLBACK:
14862 case ROW:
14863 case ROWS:
14864 case ROWID:
14865 case ROWNUM:
14866 case SAVE:
14867 case SAVEPOINT:
14868 case SECOND:
14869 case SELECT:
14870 case SELF:
14871 case SET:
14872 case SPACE:
14873 case SQL:
14874 case SQLCODE:
14875 case SQLERRM:
14876 case STATIC:
14877 case SUBTYPE:
14878 case SUBSTITUTABLE:
14879 case SUCCESSFUL:
14880 case SYSDATE:
14881 case SYS_REFCURSOR:
14882 case TEMPORARY:
14883 case TIME:
14884 case TIMESTAMP:
14885 case TIMEZONE_REGION:
14886 case TIMEZONE_ABBR:
14887 case TIMEZONE_MINUTE:
14888 case TIMEZONE_HOUR:
14889 case TRANSACTION:
14890 case TRUE:
14891 case TYPE:
14892 case UNDER:
14893 case USING:
14894 case WHILE:
14895 case YES:
14896 case SHOW:
14897 case A:
14898 case UPDATE:
14899 case DOUBLE:
14900 case DEC:
14901 case PRECISION:
14902 case INT:
14903 case NUMERIC:
14904 case NCHAR:
14905 case NVARCHAR2:
14906 case STRING:
14907 case UROWID:
14908 case VARRAY:
14909 case VARYING:
14910 case BFILE:
14911 case BLOB:
14912 case CLOB:
14913 case NCLOB:
14914 case YEAR:
14915 case LOCAL:
14916 case WITH:
14917 case ZONE:
14918 case CHARACTER:
14919 case AFTER:
14920 case BEFORE:
14921 case OLD:
14922 case PARENT:
14923 case CC_IF:
14924 case CC_ERROR:
14925 case ANALYZE:
14926 case ASSOCIATE:
14927 case AUDIT:
14928 case COMPOUND:
14929 case DATABASE:
14930 case CALL:
14931 case DDL:
14932 case DISASSOCIATE:
14933 case EACH:
14934 case FOLLOWS:
14935 case LOGOFF:
14936 case LOGON:
14937 case NESTED:
14938 case NOAUDIT:
14939 case SCHEMA:
14940 case SERVERERROR:
14941 case SHUTDOWN:
14942 case STARTUP:
14943 case STATEMENT:
14944 case STATISTICS:
14945 case SUSPEND:
14946 case TRUNCATE:
14947 case WRAPPED:
14948 case LIBRARY:
14949 case NAME:
14950 case STRUCT:
14951 case CONTEXT:
14952 case PARAMETERS:
14953 case LENGTH:
14954 case TDO:
14955 case MAXLEN:
14956 case CHARSETID:
14957 case CHARSETFORM:
14958 case ACCEPT:
14959 case ACCESSIBLE:
14960 case COPY:
14961 case DEFINE:
14962 case DISCONNECT:
14963 case HOST:
14964 case PRINT:
14965 case QUIT:
14966 case REMARK:
14967 case UNDEFINE:
14968 case VARIABLE:
14969 case WHENEVER:
14970 case ATTACH:
14971 case CAST:
14972 case TREAT:
14973 case TRIM:
14974 case LEFT:
14975 case RIGHT:
14976 case BOTH:
14977 case EMPTY:
14978 case MULTISET:
14979 case SUBMULTISET:
14980 case LEADING:
14981 case TRAILING:
14982 case CHAR_CS:
14983 case NCHAR_CS:
14984 case DBTIMEZONE:
14985 case SESSIONTIMEZONE:
14986 case AUTHENTICATED:
14987 case LINK:
14988 case SHARED:
14989 case DIRECTORY:
14990 case USER:
14991 case IDENTIFIER:
14992 case UNSIGNED_NUMERIC_LITERAL:
14993 case CHARACTER_LITERAL:
14994 case STRING_LITERAL:
14995 case QUOTED_LITERAL:
14996 ;
14997 break;
14998 default:
14999 jj_la1[176] = jj_gen;
15000 break label_39;
15001 }
15002 Statement();
15003 }
15004 label_40:
15005 while (true) {
15006 switch (jj_nt.kind) {
15007 case CC_ELSIF:
15008 ;
15009 break;
15010 default:
15011 jj_la1[177] = jj_gen;
15012 break label_40;
15013 }
15014 jj_consume_token(CC_ELSIF);
15015 ConditionalOrExpression();
15016 jj_consume_token(CC_THEN);
15017 label_41:
15018 while (true) {
15019 Statement();
15020 switch (jj_nt.kind) {
15021 case 5:
15022 case 16:
15023 case 17:
15024 case 21:
15025 case REPLACE:
15026 case DEFINER:
15027 case CURRENT_USER:
15028 case LANGUAGE:
15029 case INLINE:
15030 case ADD:
15031 case AGGREGATE:
15032 case ARRAY:
15033 case AT:
15034 case ATTRIBUTE:
15035 case AUTHID:
15036 case BEGIN:
15037 case BODY:
15038 case BULK:
15039 case BYTE:
15040 case CASCADE:
15041 case CASE:
15042 case CLOSE:
15043 case COALESCE:
15044 case COLLECT:
15045 case COLUMN:
15046 case COMMENT:
15047 case COMMIT:
15048 case CONSTRUCTOR:
15049 case CONTINUE:
15050 case CONVERT:
15051 case CURRENT:
15052 case CURSOR:
15053 case DATA:
15054 case DATE:
15055 case DAY:
15056 case DECLARE:
15057 case DELETE:
15058 case DISABLE:
15059 case EDITIONABLE:
15060 case ELEMENT:
15061 case ENABLE:
15062 case ESCAPE:
15063 case EXCEPT:
15064 case EXCEPTIONS:
15065 case EXECUTE:
15066 case EXIT:
15067 case EXTERNAL:
15068 case EXTENDS:
15069 case EXTRACT:
15070 case FALSE:
15071 case FETCH:
15072 case FINAL:
15073 case FOR:
15074 case FORALL:
15075 case FORCE:
15076 case FUNCTION:
15077 case GLOBAL:
15078 case GOTO:
15079 case HASH:
15080 case HEAP:
15081 case HOUR:
15082 case IF:
15083 case IMMEDIATE:
15084 case INDICES:
15085 case INDEXTYPE:
15086 case INDICATOR:
15087 case INSERT:
15088 case INSTANTIABLE:
15089 case INTERVAL:
15090 case INVALIDATE:
15091 case ISOLATION:
15092 case JAVA:
15093 case LEVEL:
15094 case LIMIT:
15095 case LOCK:
15096 case LOOP:
15097 case MAP:
15098 case MAX:
15099 case MEMBER:
15100 case MERGE:
15101 case MIN:
15102 case MINUTE:
15103 case MLSLABEL:
15104 case MODIFY:
15105 case MOD:
15106 case MONTH:
15107 case NATURAL:
15108 case NEW:
15109 case NEW_DOT:
15110 case NO:
15111 case NONEDITIONABLE:
15112 case NOT:
15113 case NULL:
15114 case NULLIF:
15115 case OBJECT:
15116 case OID:
15117 case OPAQUE:
15118 case OPEN:
15119 case OPERATOR:
15120 case ORGANIZATION:
15121 case OTHERS:
15122 case OVERRIDING:
15123 case PACKAGE:
15124 case PARTITION:
15125 case PIPE:
15126 case PRAGMA:
15127 case PRESERVE:
15128 case PRIVATE:
15129 case PROCEDURE:
15130 case RAISE:
15131 case RANGE:
15132 case RAW:
15133 case REAL:
15134 case RECORD:
15135 case REF:
15136 case RELEASE:
15137 case RELIES_ON:
15138 case RENAME:
15139 case RESULT:
15140 case RETURN:
15141 case RETURNING:
15142 case REVERSE:
15143 case ROLLBACK:
15144 case ROW:
15145 case ROWS:
15146 case ROWID:
15147 case ROWNUM:
15148 case SAVE:
15149 case SAVEPOINT:
15150 case SECOND:
15151 case SELECT:
15152 case SELF:
15153 case SET:
15154 case SPACE:
15155 case SQL:
15156 case SQLCODE:
15157 case SQLERRM:
15158 case STATIC:
15159 case SUBTYPE:
15160 case SUBSTITUTABLE:
15161 case SUCCESSFUL:
15162 case SYSDATE:
15163 case SYS_REFCURSOR:
15164 case TEMPORARY:
15165 case TIME:
15166 case TIMESTAMP:
15167 case TIMEZONE_REGION:
15168 case TIMEZONE_ABBR:
15169 case TIMEZONE_MINUTE:
15170 case TIMEZONE_HOUR:
15171 case TRANSACTION:
15172 case TRUE:
15173 case TYPE:
15174 case UNDER:
15175 case USING:
15176 case WHILE:
15177 case YES:
15178 case SHOW:
15179 case A:
15180 case UPDATE:
15181 case DOUBLE:
15182 case DEC:
15183 case PRECISION:
15184 case INT:
15185 case NUMERIC:
15186 case NCHAR:
15187 case NVARCHAR2:
15188 case STRING:
15189 case UROWID:
15190 case VARRAY:
15191 case VARYING:
15192 case BFILE:
15193 case BLOB:
15194 case CLOB:
15195 case NCLOB:
15196 case YEAR:
15197 case LOCAL:
15198 case WITH:
15199 case ZONE:
15200 case CHARACTER:
15201 case AFTER:
15202 case BEFORE:
15203 case OLD:
15204 case PARENT:
15205 case CC_IF:
15206 case CC_ERROR:
15207 case ANALYZE:
15208 case ASSOCIATE:
15209 case AUDIT:
15210 case COMPOUND:
15211 case DATABASE:
15212 case CALL:
15213 case DDL:
15214 case DISASSOCIATE:
15215 case EACH:
15216 case FOLLOWS:
15217 case LOGOFF:
15218 case LOGON:
15219 case NESTED:
15220 case NOAUDIT:
15221 case SCHEMA:
15222 case SERVERERROR:
15223 case SHUTDOWN:
15224 case STARTUP:
15225 case STATEMENT:
15226 case STATISTICS:
15227 case SUSPEND:
15228 case TRUNCATE:
15229 case WRAPPED:
15230 case LIBRARY:
15231 case NAME:
15232 case STRUCT:
15233 case CONTEXT:
15234 case PARAMETERS:
15235 case LENGTH:
15236 case TDO:
15237 case MAXLEN:
15238 case CHARSETID:
15239 case CHARSETFORM:
15240 case ACCEPT:
15241 case ACCESSIBLE:
15242 case COPY:
15243 case DEFINE:
15244 case DISCONNECT:
15245 case HOST:
15246 case PRINT:
15247 case QUIT:
15248 case REMARK:
15249 case UNDEFINE:
15250 case VARIABLE:
15251 case WHENEVER:
15252 case ATTACH:
15253 case CAST:
15254 case TREAT:
15255 case TRIM:
15256 case LEFT:
15257 case RIGHT:
15258 case BOTH:
15259 case EMPTY:
15260 case MULTISET:
15261 case SUBMULTISET:
15262 case LEADING:
15263 case TRAILING:
15264 case CHAR_CS:
15265 case NCHAR_CS:
15266 case DBTIMEZONE:
15267 case SESSIONTIMEZONE:
15268 case AUTHENTICATED:
15269 case LINK:
15270 case SHARED:
15271 case DIRECTORY:
15272 case USER:
15273 case IDENTIFIER:
15274 case UNSIGNED_NUMERIC_LITERAL:
15275 case CHARACTER_LITERAL:
15276 case STRING_LITERAL:
15277 case QUOTED_LITERAL:
15278 ;
15279 break;
15280 default:
15281 jj_la1[178] = jj_gen;
15282 break label_41;
15283 }
15284 }
15285 }
15286 label_42:
15287 while (true) {
15288 switch (jj_nt.kind) {
15289 case CC_ELSE:
15290 ;
15291 break;
15292 default:
15293 jj_la1[179] = jj_gen;
15294 break label_42;
15295 }
15296 jj_consume_token(CC_ELSE);
15297 label_43:
15298 while (true) {
15299 Statement();
15300 switch (jj_nt.kind) {
15301 case 5:
15302 case 16:
15303 case 17:
15304 case 21:
15305 case REPLACE:
15306 case DEFINER:
15307 case CURRENT_USER:
15308 case LANGUAGE:
15309 case INLINE:
15310 case ADD:
15311 case AGGREGATE:
15312 case ARRAY:
15313 case AT:
15314 case ATTRIBUTE:
15315 case AUTHID:
15316 case BEGIN:
15317 case BODY:
15318 case BULK:
15319 case BYTE:
15320 case CASCADE:
15321 case CASE:
15322 case CLOSE:
15323 case COALESCE:
15324 case COLLECT:
15325 case COLUMN:
15326 case COMMENT:
15327 case COMMIT:
15328 case CONSTRUCTOR:
15329 case CONTINUE:
15330 case CONVERT:
15331 case CURRENT:
15332 case CURSOR:
15333 case DATA:
15334 case DATE:
15335 case DAY:
15336 case DECLARE:
15337 case DELETE:
15338 case DISABLE:
15339 case EDITIONABLE:
15340 case ELEMENT:
15341 case ENABLE:
15342 case ESCAPE:
15343 case EXCEPT:
15344 case EXCEPTIONS:
15345 case EXECUTE:
15346 case EXIT:
15347 case EXTERNAL:
15348 case EXTENDS:
15349 case EXTRACT:
15350 case FALSE:
15351 case FETCH:
15352 case FINAL:
15353 case FOR:
15354 case FORALL:
15355 case FORCE:
15356 case FUNCTION:
15357 case GLOBAL:
15358 case GOTO:
15359 case HASH:
15360 case HEAP:
15361 case HOUR:
15362 case IF:
15363 case IMMEDIATE:
15364 case INDICES:
15365 case INDEXTYPE:
15366 case INDICATOR:
15367 case INSERT:
15368 case INSTANTIABLE:
15369 case INTERVAL:
15370 case INVALIDATE:
15371 case ISOLATION:
15372 case JAVA:
15373 case LEVEL:
15374 case LIMIT:
15375 case LOCK:
15376 case LOOP:
15377 case MAP:
15378 case MAX:
15379 case MEMBER:
15380 case MERGE:
15381 case MIN:
15382 case MINUTE:
15383 case MLSLABEL:
15384 case MODIFY:
15385 case MOD:
15386 case MONTH:
15387 case NATURAL:
15388 case NEW:
15389 case NEW_DOT:
15390 case NO:
15391 case NONEDITIONABLE:
15392 case NOT:
15393 case NULL:
15394 case NULLIF:
15395 case OBJECT:
15396 case OID:
15397 case OPAQUE:
15398 case OPEN:
15399 case OPERATOR:
15400 case ORGANIZATION:
15401 case OTHERS:
15402 case OVERRIDING:
15403 case PACKAGE:
15404 case PARTITION:
15405 case PIPE:
15406 case PRAGMA:
15407 case PRESERVE:
15408 case PRIVATE:
15409 case PROCEDURE:
15410 case RAISE:
15411 case RANGE:
15412 case RAW:
15413 case REAL:
15414 case RECORD:
15415 case REF:
15416 case RELEASE:
15417 case RELIES_ON:
15418 case RENAME:
15419 case RESULT:
15420 case RETURN:
15421 case RETURNING:
15422 case REVERSE:
15423 case ROLLBACK:
15424 case ROW:
15425 case ROWS:
15426 case ROWID:
15427 case ROWNUM:
15428 case SAVE:
15429 case SAVEPOINT:
15430 case SECOND:
15431 case SELECT:
15432 case SELF:
15433 case SET:
15434 case SPACE:
15435 case SQL:
15436 case SQLCODE:
15437 case SQLERRM:
15438 case STATIC:
15439 case SUBTYPE:
15440 case SUBSTITUTABLE:
15441 case SUCCESSFUL:
15442 case SYSDATE:
15443 case SYS_REFCURSOR:
15444 case TEMPORARY:
15445 case TIME:
15446 case TIMESTAMP:
15447 case TIMEZONE_REGION:
15448 case TIMEZONE_ABBR:
15449 case TIMEZONE_MINUTE:
15450 case TIMEZONE_HOUR:
15451 case TRANSACTION:
15452 case TRUE:
15453 case TYPE:
15454 case UNDER:
15455 case USING:
15456 case WHILE:
15457 case YES:
15458 case SHOW:
15459 case A:
15460 case UPDATE:
15461 case DOUBLE:
15462 case DEC:
15463 case PRECISION:
15464 case INT:
15465 case NUMERIC:
15466 case NCHAR:
15467 case NVARCHAR2:
15468 case STRING:
15469 case UROWID:
15470 case VARRAY:
15471 case VARYING:
15472 case BFILE:
15473 case BLOB:
15474 case CLOB:
15475 case NCLOB:
15476 case YEAR:
15477 case LOCAL:
15478 case WITH:
15479 case ZONE:
15480 case CHARACTER:
15481 case AFTER:
15482 case BEFORE:
15483 case OLD:
15484 case PARENT:
15485 case CC_IF:
15486 case CC_ERROR:
15487 case ANALYZE:
15488 case ASSOCIATE:
15489 case AUDIT:
15490 case COMPOUND:
15491 case DATABASE:
15492 case CALL:
15493 case DDL:
15494 case DISASSOCIATE:
15495 case EACH:
15496 case FOLLOWS:
15497 case LOGOFF:
15498 case LOGON:
15499 case NESTED:
15500 case NOAUDIT:
15501 case SCHEMA:
15502 case SERVERERROR:
15503 case SHUTDOWN:
15504 case STARTUP:
15505 case STATEMENT:
15506 case STATISTICS:
15507 case SUSPEND:
15508 case TRUNCATE:
15509 case WRAPPED:
15510 case LIBRARY:
15511 case NAME:
15512 case STRUCT:
15513 case CONTEXT:
15514 case PARAMETERS:
15515 case LENGTH:
15516 case TDO:
15517 case MAXLEN:
15518 case CHARSETID:
15519 case CHARSETFORM:
15520 case ACCEPT:
15521 case ACCESSIBLE:
15522 case COPY:
15523 case DEFINE:
15524 case DISCONNECT:
15525 case HOST:
15526 case PRINT:
15527 case QUIT:
15528 case REMARK:
15529 case UNDEFINE:
15530 case VARIABLE:
15531 case WHENEVER:
15532 case ATTACH:
15533 case CAST:
15534 case TREAT:
15535 case TRIM:
15536 case LEFT:
15537 case RIGHT:
15538 case BOTH:
15539 case EMPTY:
15540 case MULTISET:
15541 case SUBMULTISET:
15542 case LEADING:
15543 case TRAILING:
15544 case CHAR_CS:
15545 case NCHAR_CS:
15546 case DBTIMEZONE:
15547 case SESSIONTIMEZONE:
15548 case AUTHENTICATED:
15549 case LINK:
15550 case SHARED:
15551 case DIRECTORY:
15552 case USER:
15553 case IDENTIFIER:
15554 case UNSIGNED_NUMERIC_LITERAL:
15555 case CHARACTER_LITERAL:
15556 case STRING_LITERAL:
15557 case QUOTED_LITERAL:
15558 ;
15559 break;
15560 default:
15561 jj_la1[180] = jj_gen;
15562 break label_43;
15563 }
15564 }
15565 }
15566 jj_consume_token(CC_END);
15567 break;
15568 case CC_ERROR:
15569 jj_consume_token(CC_ERROR);
15570 Expression();
15571 jj_consume_token(CC_END);
15572 break;
15573 default:
15574 jj_la1[181] = jj_gen;
15575 jj_consume_token(-1);
15576 throw new ParseException();
15577 }
15578 jjtree.closeNodeScope(jjtn000, true);
15579 jjtc000 = false;
15580 {if (true) return jjtn000 ;}
15581 } catch (Throwable jjte000) {
15582 if (jjtc000) {
15583 jjtree.clearNodeScope(jjtn000);
15584 jjtc000 = false;
15585 } else {
15586 jjtree.popNode();
15587 }
15588 if (jjte000 instanceof RuntimeException) {
15589 {if (true) throw (RuntimeException)jjte000;}
15590 }
15591 if (jjte000 instanceof ParseException) {
15592 {if (true) throw (ParseException)jjte000;}
15593 }
15594 {if (true) throw (Error)jjte000;}
15595 } finally {
15596 if (jjtc000) {
15597 jjtree.closeNodeScope(jjtn000, true);
15598 }
15599 }
15600 throw new Error("Missing return statement in function");
15601 }
15602
15603 final public ASTSubTypeDefinition SubTypeDefinition() throws ParseException {
15604
15605 ASTSubTypeDefinition jjtn000 = new ASTSubTypeDefinition(this, JJTSUBTYPEDEFINITION);
15606 boolean jjtc000 = true;
15607 jjtree.openNodeScope(jjtn000);Token start, subtype_name=null, constraint=null, base_type=null;
15608 Token collection = null, collection2 = null;
15609 PLSQLNode name = null;
15610 PLSQLNode startElement = null, endElement = null;
15611 PLSQLNode baseType = null, returnType = null, indexBy = null ;
15612 int lastField = 0;
15613 try {
15614 switch (jj_nt.kind) {
15615 case SUBTYPE:
15616 jj_consume_token(SUBTYPE);
15617 name = QualifiedID();
15618 jj_consume_token(IS);
15619 Datatype();
15620 switch (jj_nt.kind) {
15621 case 5:
15622 case RANGE:
15623 switch (jj_nt.kind) {
15624 case 5:
15625 jj_consume_token(5);
15626 jj_consume_token(IDENTIFIER);
15627 jj_consume_token(7);
15628 break;
15629 case RANGE:
15630 jj_consume_token(RANGE);
15631 UnaryExpression(true);
15632 jj_consume_token(12);
15633 UnaryExpression(true);
15634 break;
15635 default:
15636 jj_la1[182] = jj_gen;
15637 jj_consume_token(-1);
15638 throw new ParseException();
15639 }
15640 break;
15641 default:
15642 jj_la1[183] = jj_gen;
15643 ;
15644 }
15645 switch (jj_nt.kind) {
15646 case NOT:
15647 jj_consume_token(NOT);
15648 jj_consume_token(NULL);
15649 break;
15650 default:
15651 jj_la1[184] = jj_gen;
15652 ;
15653 }
15654 break;
15655 case TYPE:
15656 jj_consume_token(TYPE);
15657 name = QualifiedID();
15658 switch (jj_nt.kind) {
15659 case IS:
15660 jj_consume_token(IS);
15661 break;
15662 case AS:
15663 jj_consume_token(AS);
15664 break;
15665 default:
15666 jj_la1[185] = jj_gen;
15667 jj_consume_token(-1);
15668 throw new ParseException();
15669 }
15670 if (jj_2_44(2)) {
15671 jj_consume_token(NEW);
15672 switch (jj_nt.kind) {
15673 case CHAR_BASE:
15674 jj_consume_token(CHAR_BASE);
15675 break;
15676 case DATE_BASE:
15677 jj_consume_token(DATE_BASE);
15678 break;
15679 case CLOB_BASE:
15680 jj_consume_token(CLOB_BASE);
15681 break;
15682 case BLOB_BASE:
15683 jj_consume_token(BLOB_BASE);
15684 break;
15685 case BFILE_BASE:
15686 jj_consume_token(BFILE_BASE);
15687 break;
15688 case NUMBER_BASE:
15689 jj_consume_token(NUMBER_BASE);
15690 break;
15691 default:
15692 jj_la1[186] = jj_gen;
15693 jj_consume_token(-1);
15694 throw new ParseException();
15695 }
15696 } else {
15697 switch (jj_nt.kind) {
15698 case OBJECT:
15699 jj_consume_token(OBJECT);
15700 jj_consume_token(5);
15701 FieldDeclaration();
15702 label_44:
15703 while (true) {
15704 switch (jj_nt.kind) {
15705 case 6:
15706 ;
15707 break;
15708 default:
15709 jj_la1[187] = jj_gen;
15710 break label_44;
15711 }
15712 jj_consume_token(6);
15713 FieldDeclaration();
15714 }
15715 jj_consume_token(7);
15716 break;
15717 case RECORD:
15718 jj_consume_token(RECORD);
15719 jj_consume_token(5);
15720 FieldDeclaration();
15721 label_45:
15722 while (true) {
15723 switch (jj_nt.kind) {
15724 case 6:
15725 ;
15726 break;
15727 default:
15728 jj_la1[188] = jj_gen;
15729 break label_45;
15730 }
15731 jj_consume_token(6);
15732 FieldDeclaration();
15733 }
15734 jj_consume_token(7);
15735 break;
15736 case TABLE:
15737 case VARRAY:
15738 case VARYING:
15739 switch (jj_nt.kind) {
15740 case TABLE:
15741 jj_consume_token(TABLE);
15742 break;
15743 case VARRAY:
15744 jj_consume_token(VARRAY);
15745 break;
15746 case VARYING:
15747 jj_consume_token(VARYING);
15748 jj_consume_token(ARRAY);
15749 break;
15750 default:
15751 jj_la1[189] = jj_gen;
15752 jj_consume_token(-1);
15753 throw new ParseException();
15754 }
15755 switch (jj_nt.kind) {
15756 case 5:
15757 jj_consume_token(5);
15758 NumericLiteral();
15759 jj_consume_token(7);
15760 break;
15761 default:
15762 jj_la1[190] = jj_gen;
15763 ;
15764 }
15765 jj_consume_token(OF);
15766 Datatype();
15767 switch (jj_nt.kind) {
15768 case NOT:
15769 jj_consume_token(NOT);
15770 jj_consume_token(NULL);
15771 break;
15772 default:
15773 jj_la1[191] = jj_gen;
15774 ;
15775 }
15776 switch (jj_nt.kind) {
15777 case INDEX:
15778 jj_consume_token(INDEX);
15779 jj_consume_token(BY);
15780 Datatype();
15781 break;
15782 default:
15783 jj_la1[192] = jj_gen;
15784 ;
15785 }
15786 break;
15787 case REF:
15788 jj_consume_token(REF);
15789 jj_consume_token(CURSOR);
15790 switch (jj_nt.kind) {
15791 case RETURN:
15792 jj_consume_token(RETURN);
15793 Datatype();
15794 break;
15795 default:
15796 jj_la1[193] = jj_gen;
15797 ;
15798 }
15799 break;
15800 case 5:
15801 jj_consume_token(5);
15802 Expression();
15803 label_46:
15804 while (true) {
15805 switch (jj_nt.kind) {
15806 case 6:
15807 ;
15808 break;
15809 default:
15810 jj_la1[194] = jj_gen;
15811 break label_46;
15812 }
15813 jj_consume_token(6);
15814 Expression();
15815 }
15816 jj_consume_token(7);
15817 break;
15818 case REPLACE:
15819 case DEFINER:
15820 case CURRENT_USER:
15821 case LANGUAGE:
15822 case INLINE:
15823 case ADD:
15824 case AGGREGATE:
15825 case ARRAY:
15826 case AT:
15827 case ATTRIBUTE:
15828 case AUTHID:
15829 case BINARY_INTEGER:
15830 case BODY:
15831 case BOOLEAN:
15832 case BULK:
15833 case BYTE:
15834 case CASCADE:
15835 case CHAR:
15836 case CHAR_BASE:
15837 case CLOSE:
15838 case COALESCE:
15839 case COLLECT:
15840 case COLUMN:
15841 case COMMENT:
15842 case COMMIT:
15843 case CONSTRUCTOR:
15844 case CONTINUE:
15845 case CONVERT:
15846 case CURRENT:
15847 case CURSOR:
15848 case DATA:
15849 case DATE:
15850 case DAY:
15851 case DECIMAL:
15852 case DISABLE:
15853 case EDITIONABLE:
15854 case ELEMENT:
15855 case ENABLE:
15856 case ESCAPE:
15857 case EXCEPT:
15858 case EXCEPTIONS:
15859 case EXIT:
15860 case EXTERNAL:
15861 case EXTENDS:
15862 case EXTRACT:
15863 case FALSE:
15864 case FINAL:
15865 case FLOAT:
15866 case FORCE:
15867 case FUNCTION:
15868 case GLOBAL:
15869 case HASH:
15870 case HEAP:
15871 case HOUR:
15872 case IMMEDIATE:
15873 case INDICES:
15874 case INDEXTYPE:
15875 case INDICATOR:
15876 case INSTANTIABLE:
15877 case INTEGER:
15878 case INTERVAL:
15879 case INVALIDATE:
15880 case ISOLATION:
15881 case JAVA:
15882 case LEVEL:
15883 case LIMIT:
15884 case LONG:
15885 case LOOP:
15886 case MAP:
15887 case MAX:
15888 case MEMBER:
15889 case MERGE:
15890 case MIN:
15891 case MINUTE:
15892 case MLSLABEL:
15893 case MODIFY:
15894 case MOD:
15895 case MONTH:
15896 case NATURAL:
15897 case NATURALN:
15898 case NEW:
15899 case NO:
15900 case NONEDITIONABLE:
15901 case NULLIF:
15902 case NUMBER:
15903 case BFILE_BASE:
15904 case BLOB_BASE:
15905 case CLOB_BASE:
15906 case DATE_BASE:
15907 case NUMBER_BASE:
15908 case OID:
15909 case OPAQUE:
15910 case OPEN:
15911 case OPERATOR:
15912 case ORGANIZATION:
15913 case OTHERS:
15914 case OVERRIDING:
15915 case PACKAGE:
15916 case PARTITION:
15917 case PLS_INTEGER:
15918 case POSITIVE:
15919 case POSITIVEN:
15920 case PRESERVE:
15921 case PRIVATE:
15922 case PROCEDURE:
15923 case RANGE:
15924 case RAW:
15925 case REAL:
15926 case RELEASE:
15927 case RELIES_ON:
15928 case RENAME:
15929 case RESULT:
15930 case RETURN:
15931 case RETURNING:
15932 case REVERSE:
15933 case ROLLBACK:
15934 case ROW:
15935 case ROWS:
15936 case ROWID:
15937 case ROWNUM:
15938 case SAVE:
15939 case SAVEPOINT:
15940 case SECOND:
15941 case SELF:
15942 case SET:
15943 case SMALLINT:
15944 case SPACE:
15945 case SQL:
15946 case SQLCODE:
15947 case SQLERRM:
15948 case STATIC:
15949 case SUBTYPE:
15950 case SUBSTITUTABLE:
15951 case SUCCESSFUL:
15952 case SYSDATE:
15953 case SYS_REFCURSOR:
15954 case TEMPORARY:
15955 case TIME:
15956 case TIMESTAMP:
15957 case TIMEZONE_REGION:
15958 case TIMEZONE_ABBR:
15959 case TIMEZONE_MINUTE:
15960 case TIMEZONE_HOUR:
15961 case TRANSACTION:
15962 case TRUE:
15963 case TYPE:
15964 case UNDER:
15965 case USING:
15966 case YES:
15967 case SHOW:
15968 case A:
15969 case VARCHAR:
15970 case VARCHAR2:
15971 case DOUBLE:
15972 case DEC:
15973 case PRECISION:
15974 case INT:
15975 case NUMERIC:
15976 case SIGNTYPE:
15977 case NCHAR:
15978 case NVARCHAR2:
15979 case STRING:
15980 case UROWID:
15981 case BFILE:
15982 case BLOB:
15983 case CLOB:
15984 case NCLOB:
15985 case YEAR:
15986 case LOCAL:
15987 case ZONE:
15988 case CHARACTER:
15989 case AFTER:
15990 case BEFORE:
15991 case OLD:
15992 case PARENT:
15993 case CC_IF:
15994 case ANALYZE:
15995 case ASSOCIATE:
15996 case AUDIT:
15997 case COMPOUND:
15998 case DATABASE:
15999 case CALL:
16000 case DDL:
16001 case DISASSOCIATE:
16002 case EACH:
16003 case FOLLOWS:
16004 case LOGOFF:
16005 case LOGON:
16006 case NESTED:
16007 case NOAUDIT:
16008 case SCHEMA:
16009 case SERVERERROR:
16010 case SHUTDOWN:
16011 case STARTUP:
16012 case STATEMENT:
16013 case STATISTICS:
16014 case SUSPEND:
16015 case TRUNCATE:
16016 case WRAPPED:
16017 case LIBRARY:
16018 case NAME:
16019 case STRUCT:
16020 case CONTEXT:
16021 case PARAMETERS:
16022 case LENGTH:
16023 case TDO:
16024 case MAXLEN:
16025 case CHARSETID:
16026 case CHARSETFORM:
16027 case ACCEPT:
16028 case ACCESSIBLE:
16029 case COPY:
16030 case DEFINE:
16031 case DISCONNECT:
16032 case HOST:
16033 case PRINT:
16034 case QUIT:
16035 case REMARK:
16036 case UNDEFINE:
16037 case VARIABLE:
16038 case WHENEVER:
16039 case ATTACH:
16040 case CAST:
16041 case TREAT:
16042 case TRIM:
16043 case LEFT:
16044 case RIGHT:
16045 case BOTH:
16046 case EMPTY:
16047 case MULTISET:
16048 case SUBMULTISET:
16049 case LEADING:
16050 case TRAILING:
16051 case CHAR_CS:
16052 case NCHAR_CS:
16053 case DBTIMEZONE:
16054 case SESSIONTIMEZONE:
16055 case AUTHENTICATED:
16056 case LINK:
16057 case SHARED:
16058 case DIRECTORY:
16059 case USER:
16060 case IDENTIFIER:
16061 case QUOTED_LITERAL:
16062 Datatype();
16063 break;
16064 default:
16065 jj_la1[195] = jj_gen;
16066 jj_consume_token(-1);
16067 throw new ParseException();
16068 }
16069 }
16070 break;
16071 default:
16072 jj_la1[196] = jj_gen;
16073 jj_consume_token(-1);
16074 throw new ParseException();
16075 }
16076 jj_consume_token(4);
16077 jjtree.closeNodeScope(jjtn000, true);
16078 jjtc000 = false;
16079 jjtn000.setImage(name.getImage()) ; {if (true) return jjtn000 ;}
16080 } catch (Throwable jjte000) {
16081 if (jjtc000) {
16082 jjtree.clearNodeScope(jjtn000);
16083 jjtc000 = false;
16084 } else {
16085 jjtree.popNode();
16086 }
16087 if (jjte000 instanceof RuntimeException) {
16088 {if (true) throw (RuntimeException)jjte000;}
16089 }
16090 if (jjte000 instanceof ParseException) {
16091 {if (true) throw (ParseException)jjte000;}
16092 }
16093 {if (true) throw (Error)jjte000;}
16094 } finally {
16095 if (jjtc000) {
16096 jjtree.closeNodeScope(jjtn000, true);
16097 }
16098 }
16099 throw new Error("Missing return statement in function");
16100 }
16101
16102 final public ASTFieldDeclaration FieldDeclaration() throws ParseException {
16103
16104 ASTFieldDeclaration jjtn000 = new ASTFieldDeclaration(this, JJTFIELDDECLARATION);
16105 boolean jjtc000 = true;
16106 jjtree.openNodeScope(jjtn000);PLSQLNode name;
16107 PLSQLNode dataType;
16108 PLSQLNode defaultValue = null;
16109 try {
16110 name = ID();
16111 Datatype();
16112 switch (jj_nt.kind) {
16113 case NOT:
16114 case NULL:
16115 switch (jj_nt.kind) {
16116 case NOT:
16117 jj_consume_token(NOT);
16118 break;
16119 default:
16120 jj_la1[197] = jj_gen;
16121 ;
16122 }
16123 jj_consume_token(NULL);
16124 break;
16125 default:
16126 jj_la1[198] = jj_gen;
16127 ;
16128 }
16129 switch (jj_nt.kind) {
16130 case 9:
16131 case _DEFAULT:
16132 switch (jj_nt.kind) {
16133 case 9:
16134 jj_consume_token(9);
16135 jj_consume_token(10);
16136 break;
16137 case _DEFAULT:
16138 jj_consume_token(_DEFAULT);
16139 break;
16140 default:
16141 jj_la1[199] = jj_gen;
16142 jj_consume_token(-1);
16143 throw new ParseException();
16144 }
16145 Expression();
16146 break;
16147 default:
16148 jj_la1[200] = jj_gen;
16149 ;
16150 }
16151 jjtree.closeNodeScope(jjtn000, true);
16152 jjtc000 = false;
16153 jjtn000.setImage(name.getImage()) ; {if (true) return jjtn000 ;}
16154 } catch (Throwable jjte000) {
16155 if (jjtc000) {
16156 jjtree.clearNodeScope(jjtn000);
16157 jjtc000 = false;
16158 } else {
16159 jjtree.popNode();
16160 }
16161 if (jjte000 instanceof RuntimeException) {
16162 {if (true) throw (RuntimeException)jjte000;}
16163 }
16164 if (jjte000 instanceof ParseException) {
16165 {if (true) throw (ParseException)jjte000;}
16166 }
16167 {if (true) throw (Error)jjte000;}
16168 } finally {
16169 if (jjtc000) {
16170 jjtree.closeNodeScope(jjtn000, true);
16171 }
16172 }
16173 throw new Error("Missing return statement in function");
16174 }
16175
16176 final public ASTCollectionTypeDefinition CollectionTypeDefinition() throws ParseException {
16177
16178 ASTCollectionTypeDefinition jjtn000 = new ASTCollectionTypeDefinition(this, JJTCOLLECTIONTYPEDEFINITION);
16179 boolean jjtc000 = true;
16180 jjtree.openNodeScope(jjtn000);Token t = null ;
16181 try {
16182 t = jj_consume_token(IDENTIFIER);
16183 jjtree.closeNodeScope(jjtn000, true);
16184 jjtc000 = false;
16185 jjtn000.setImage(t.image) ; {if (true) return jjtn000 ;}
16186 } finally {
16187 if (jjtc000) {
16188 jjtree.closeNodeScope(jjtn000, true);
16189 }
16190 }
16191 throw new Error("Missing return statement in function");
16192 }
16193
16194 final public ASTCollectionDeclaration CollectionDeclaration() throws ParseException {
16195
16196 ASTCollectionDeclaration jjtn000 = new ASTCollectionDeclaration(this, JJTCOLLECTIONDECLARATION);
16197 boolean jjtc000 = true;
16198 jjtree.openNodeScope(jjtn000);Token t = null ;
16199 try {
16200 t = jj_consume_token(IDENTIFIER);
16201 jjtree.closeNodeScope(jjtn000, true);
16202 jjtc000 = false;
16203 jjtn000.setImage(t.image) ; {if (true) return jjtn000 ;}
16204 } finally {
16205 if (jjtc000) {
16206 jjtree.closeNodeScope(jjtn000, true);
16207 }
16208 }
16209 throw new Error("Missing return statement in function");
16210 }
16211
16212 final public ASTObjectDeclaration ObjectDeclaration() throws ParseException {
16213
16214 ASTObjectDeclaration jjtn000 = new ASTObjectDeclaration(this, JJTOBJECTDECLARATION);
16215 boolean jjtc000 = true;
16216 jjtree.openNodeScope(jjtn000);Token t = null ;
16217 try {
16218 t = jj_consume_token(IDENTIFIER);
16219 jjtree.closeNodeScope(jjtn000, true);
16220 jjtc000 = false;
16221 jjtn000.setImage(t.image) ; {if (true) return jjtn000 ;}
16222 } finally {
16223 if (jjtc000) {
16224 jjtree.closeNodeScope(jjtn000, true);
16225 }
16226 }
16227 throw new Error("Missing return statement in function");
16228 }
16229
16230
16231 final public ASTCallSpecTail CallSpecTail() throws ParseException {
16232
16233 ASTCallSpecTail jjtn000 = new ASTCallSpecTail(this, JJTCALLSPECTAIL);
16234 boolean jjtc000 = true;
16235 jjtree.openNodeScope(jjtn000);
16236 try {
16237 switch (jj_nt.kind) {
16238 case EXTERNAL:
16239 jj_consume_token(EXTERNAL);
16240 break;
16241 case LANGUAGE:
16242 jj_consume_token(LANGUAGE);
16243 switch (jj_nt.kind) {
16244 case IDENTIFIER:
16245 jj_consume_token(IDENTIFIER);
16246 break;
16247 case JAVA:
16248 jj_consume_token(JAVA);
16249 break;
16250 default:
16251 jj_la1[201] = jj_gen;
16252 jj_consume_token(-1);
16253 throw new ParseException();
16254 }
16255 break;
16256 default:
16257 jj_la1[202] = jj_gen;
16258 jj_consume_token(-1);
16259 throw new ParseException();
16260 }
16261 label_47:
16262 while (true) {
16263 switch (jj_nt.kind) {
16264 case WITH:
16265 case LIBRARY:
16266 case NAME:
16267 case PARAMETERS:
16268 ;
16269 break;
16270 default:
16271 jj_la1[203] = jj_gen;
16272 break label_47;
16273 }
16274 switch (jj_nt.kind) {
16275 case LIBRARY:
16276 jj_consume_token(LIBRARY);
16277 switch (jj_nt.kind) {
16278 case IDENTIFIER:
16279 jj_consume_token(IDENTIFIER);
16280 break;
16281 case QUOTED_LITERAL:
16282 jj_consume_token(QUOTED_LITERAL);
16283 break;
16284 case STRING_LITERAL:
16285 StringLiteral();
16286 break;
16287 default:
16288 jj_la1[204] = jj_gen;
16289 jj_consume_token(-1);
16290 throw new ParseException();
16291 }
16292 switch (jj_nt.kind) {
16293 case 3:
16294 jj_consume_token(3);
16295 switch (jj_nt.kind) {
16296 case IDENTIFIER:
16297 jj_consume_token(IDENTIFIER);
16298 break;
16299 case QUOTED_LITERAL:
16300 jj_consume_token(QUOTED_LITERAL);
16301 break;
16302 case STRING_LITERAL:
16303 StringLiteral();
16304 break;
16305 default:
16306 jj_la1[205] = jj_gen;
16307 jj_consume_token(-1);
16308 throw new ParseException();
16309 }
16310 break;
16311 default:
16312 jj_la1[206] = jj_gen;
16313 ;
16314 }
16315 break;
16316 case NAME:
16317 jj_consume_token(NAME);
16318 switch (jj_nt.kind) {
16319 case IDENTIFIER:
16320 jj_consume_token(IDENTIFIER);
16321 break;
16322 case QUOTED_LITERAL:
16323 jj_consume_token(QUOTED_LITERAL);
16324 break;
16325 case STRING_LITERAL:
16326 StringLiteral();
16327 break;
16328 default:
16329 jj_la1[207] = jj_gen;
16330 jj_consume_token(-1);
16331 throw new ParseException();
16332 }
16333 break;
16334 case WITH:
16335 jj_consume_token(WITH);
16336 jj_consume_token(CONTEXT);
16337 break;
16338 case PARAMETERS:
16339 jj_consume_token(PARAMETERS);
16340 SkipPastNextOccurrence(")");
16341 break;
16342 default:
16343 jj_la1[208] = jj_gen;
16344 jj_consume_token(-1);
16345 throw new ParseException();
16346 }
16347 }
16348 jjtree.closeNodeScope(jjtn000, true);
16349 jjtc000 = false;
16350 {if (true) return jjtn000 ;}
16351 } catch (Throwable jjte000) {
16352 if (jjtc000) {
16353 jjtree.clearNodeScope(jjtn000);
16354 jjtc000 = false;
16355 } else {
16356 jjtree.popNode();
16357 }
16358 if (jjte000 instanceof RuntimeException) {
16359 {if (true) throw (RuntimeException)jjte000;}
16360 }
16361 if (jjte000 instanceof ParseException) {
16362 {if (true) throw (ParseException)jjte000;}
16363 }
16364 {if (true) throw (Error)jjte000;}
16365 } finally {
16366 if (jjtc000) {
16367 jjtree.closeNodeScope(jjtn000, true);
16368 }
16369 }
16370 throw new Error("Missing return statement in function");
16371 }
16372
16373
16374 final public ASTCursorUnit CursorUnit() throws ParseException {
16375
16376 ASTCursorUnit jjtn000 = new ASTCursorUnit(this, JJTCURSORUNIT);
16377 boolean jjtc000 = true;
16378 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
16379 try {
16380 jj_consume_token(CURSOR);
16381 simpleNode = ID();
16382 switch (jj_nt.kind) {
16383 case 5:
16384 FormalParameters();
16385 break;
16386 default:
16387 jj_la1[209] = jj_gen;
16388 ;
16389 }
16390 switch (jj_nt.kind) {
16391 case RETURN:
16392 jj_consume_token(RETURN);
16393 Datatype();
16394 break;
16395 default:
16396 jj_la1[210] = jj_gen;
16397 ;
16398 }
16399 switch (jj_nt.kind) {
16400 case IS:
16401 jj_consume_token(IS);
16402 label_48:
16403 while (true) {
16404 switch (jj_nt.kind) {
16405 case 5:
16406 ;
16407 break;
16408 default:
16409 jj_la1[211] = jj_gen;
16410 break label_48;
16411 }
16412 jj_consume_token(5);
16413 }
16414 SqlStatement(null,";");
16415 break;
16416 default:
16417 jj_la1[212] = jj_gen;
16418 ;
16419 }
16420 jj_consume_token(4);
16421 jjtree.closeNodeScope(jjtn000, true);
16422 jjtc000 = false;
16423 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
16424 } catch (Throwable jjte000) {
16425 if (jjtc000) {
16426 jjtree.clearNodeScope(jjtn000);
16427 jjtc000 = false;
16428 } else {
16429 jjtree.popNode();
16430 }
16431 if (jjte000 instanceof RuntimeException) {
16432 {if (true) throw (RuntimeException)jjte000;}
16433 }
16434 if (jjte000 instanceof ParseException) {
16435 {if (true) throw (ParseException)jjte000;}
16436 }
16437 {if (true) throw (Error)jjte000;}
16438 } finally {
16439 if (jjtc000) {
16440 jjtree.closeNodeScope(jjtn000, true);
16441 }
16442 }
16443 throw new Error("Missing return statement in function");
16444 }
16445
16446 final public ASTCursorSpecification CursorSpecification() throws ParseException {
16447
16448 ASTCursorSpecification jjtn000 = new ASTCursorSpecification(this, JJTCURSORSPECIFICATION);
16449 boolean jjtc000 = true;
16450 jjtree.openNodeScope(jjtn000);
16451 try {
16452 CursorUnit();
16453 jjtree.closeNodeScope(jjtn000, true);
16454 jjtc000 = false;
16455 {if (true) return jjtn000 ;}
16456 } catch (Throwable jjte000) {
16457 if (jjtc000) {
16458 jjtree.clearNodeScope(jjtn000);
16459 jjtc000 = false;
16460 } else {
16461 jjtree.popNode();
16462 }
16463 if (jjte000 instanceof RuntimeException) {
16464 {if (true) throw (RuntimeException)jjte000;}
16465 }
16466 if (jjte000 instanceof ParseException) {
16467 {if (true) throw (ParseException)jjte000;}
16468 }
16469 {if (true) throw (Error)jjte000;}
16470 } finally {
16471 if (jjtc000) {
16472 jjtree.closeNodeScope(jjtn000, true);
16473 }
16474 }
16475 throw new Error("Missing return statement in function");
16476 }
16477
16478 final public ASTCursorBody CursorBody() throws ParseException {
16479
16480 ASTCursorBody jjtn000 = new ASTCursorBody(this, JJTCURSORBODY);
16481 boolean jjtc000 = true;
16482 jjtree.openNodeScope(jjtn000);
16483 try {
16484 CursorUnit();
16485 jjtree.closeNodeScope(jjtn000, true);
16486 jjtc000 = false;
16487 {if (true) return jjtn000 ;}
16488 } catch (Throwable jjte000) {
16489 if (jjtc000) {
16490 jjtree.clearNodeScope(jjtn000);
16491 jjtc000 = false;
16492 } else {
16493 jjtree.popNode();
16494 }
16495 if (jjte000 instanceof RuntimeException) {
16496 {if (true) throw (RuntimeException)jjte000;}
16497 }
16498 if (jjte000 instanceof ParseException) {
16499 {if (true) throw (ParseException)jjte000;}
16500 }
16501 {if (true) throw (Error)jjte000;}
16502 } finally {
16503 if (jjtc000) {
16504 jjtree.closeNodeScope(jjtn000, true);
16505 }
16506 }
16507 throw new Error("Missing return statement in function");
16508 }
16509
16510
16511
16512
16513
16514
16515
16516
16517
16518
16519
16520
16521
16522 final public ASTExpression Expression() throws ParseException {
16523
16524 ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
16525 boolean jjtc000 = true;
16526 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
16527 StringBuilder sb = new StringBuilder() ;
16528 try {
16529 if (jj_2_45(2147483647)) {
16530 simpleNode = Assignment();
16531 sb.append(simpleNode.getImage());
16532 } else {
16533 switch (jj_nt.kind) {
16534 case 5:
16535 case 16:
16536 case 17:
16537 case REPLACE:
16538 case DEFINER:
16539 case CURRENT_USER:
16540 case LANGUAGE:
16541 case INLINE:
16542 case ADD:
16543 case AGGREGATE:
16544 case ARRAY:
16545 case AT:
16546 case ATTRIBUTE:
16547 case AUTHID:
16548 case BODY:
16549 case BULK:
16550 case BYTE:
16551 case CASCADE:
16552 case CASE:
16553 case CLOSE:
16554 case COALESCE:
16555 case COLLECT:
16556 case COLUMN:
16557 case COMMENT:
16558 case COMMIT:
16559 case CONSTRUCTOR:
16560 case CONTINUE:
16561 case CONVERT:
16562 case CURRENT:
16563 case CURSOR:
16564 case DATA:
16565 case DATE:
16566 case DAY:
16567 case DISABLE:
16568 case EDITIONABLE:
16569 case ELEMENT:
16570 case ENABLE:
16571 case ESCAPE:
16572 case EXCEPT:
16573 case EXCEPTIONS:
16574 case EXIT:
16575 case EXTERNAL:
16576 case EXTENDS:
16577 case EXTRACT:
16578 case FALSE:
16579 case FINAL:
16580 case FORCE:
16581 case FUNCTION:
16582 case GLOBAL:
16583 case HASH:
16584 case HEAP:
16585 case HOUR:
16586 case IMMEDIATE:
16587 case INDICES:
16588 case INDEXTYPE:
16589 case INDICATOR:
16590 case INSTANTIABLE:
16591 case INTERVAL:
16592 case INVALIDATE:
16593 case ISOLATION:
16594 case JAVA:
16595 case LEVEL:
16596 case LIMIT:
16597 case LOOP:
16598 case MAP:
16599 case MAX:
16600 case MEMBER:
16601 case MERGE:
16602 case MIN:
16603 case MINUTE:
16604 case MLSLABEL:
16605 case MODIFY:
16606 case MOD:
16607 case MONTH:
16608 case NATURAL:
16609 case NEW:
16610 case NEW_DOT:
16611 case NO:
16612 case NONEDITIONABLE:
16613 case NOT:
16614 case NULL:
16615 case NULLIF:
16616 case OBJECT:
16617 case OID:
16618 case OPAQUE:
16619 case OPEN:
16620 case OPERATOR:
16621 case ORGANIZATION:
16622 case OTHERS:
16623 case OVERRIDING:
16624 case PACKAGE:
16625 case PARTITION:
16626 case PRESERVE:
16627 case PRIVATE:
16628 case PROCEDURE:
16629 case RANGE:
16630 case RAW:
16631 case REAL:
16632 case RECORD:
16633 case REF:
16634 case RELEASE:
16635 case RELIES_ON:
16636 case RENAME:
16637 case RESULT:
16638 case RETURN:
16639 case RETURNING:
16640 case REVERSE:
16641 case ROLLBACK:
16642 case ROW:
16643 case ROWS:
16644 case ROWID:
16645 case ROWNUM:
16646 case SAVE:
16647 case SAVEPOINT:
16648 case SECOND:
16649 case SELECT:
16650 case SELF:
16651 case SET:
16652 case SPACE:
16653 case SQL:
16654 case SQLCODE:
16655 case SQLERRM:
16656 case STATIC:
16657 case SUBTYPE:
16658 case SUBSTITUTABLE:
16659 case SUCCESSFUL:
16660 case SYSDATE:
16661 case SYS_REFCURSOR:
16662 case TEMPORARY:
16663 case TIME:
16664 case TIMESTAMP:
16665 case TIMEZONE_REGION:
16666 case TIMEZONE_ABBR:
16667 case TIMEZONE_MINUTE:
16668 case TIMEZONE_HOUR:
16669 case TRANSACTION:
16670 case TRUE:
16671 case TYPE:
16672 case UNDER:
16673 case USING:
16674 case YES:
16675 case SHOW:
16676 case A:
16677 case DOUBLE:
16678 case DEC:
16679 case PRECISION:
16680 case INT:
16681 case NUMERIC:
16682 case NCHAR:
16683 case NVARCHAR2:
16684 case STRING:
16685 case UROWID:
16686 case VARRAY:
16687 case VARYING:
16688 case BFILE:
16689 case BLOB:
16690 case CLOB:
16691 case NCLOB:
16692 case YEAR:
16693 case LOCAL:
16694 case WITH:
16695 case ZONE:
16696 case CHARACTER:
16697 case AFTER:
16698 case BEFORE:
16699 case OLD:
16700 case PARENT:
16701 case ANALYZE:
16702 case ASSOCIATE:
16703 case AUDIT:
16704 case COMPOUND:
16705 case DATABASE:
16706 case CALL:
16707 case DDL:
16708 case DISASSOCIATE:
16709 case EACH:
16710 case FOLLOWS:
16711 case LOGOFF:
16712 case LOGON:
16713 case NESTED:
16714 case NOAUDIT:
16715 case SCHEMA:
16716 case SERVERERROR:
16717 case SHUTDOWN:
16718 case STARTUP:
16719 case STATEMENT:
16720 case STATISTICS:
16721 case SUSPEND:
16722 case TRUNCATE:
16723 case WRAPPED:
16724 case LIBRARY:
16725 case NAME:
16726 case STRUCT:
16727 case CONTEXT:
16728 case PARAMETERS:
16729 case LENGTH:
16730 case TDO:
16731 case MAXLEN:
16732 case CHARSETID:
16733 case CHARSETFORM:
16734 case ACCEPT:
16735 case ACCESSIBLE:
16736 case COPY:
16737 case DEFINE:
16738 case DISCONNECT:
16739 case HOST:
16740 case PRINT:
16741 case QUIT:
16742 case REMARK:
16743 case UNDEFINE:
16744 case VARIABLE:
16745 case WHENEVER:
16746 case ATTACH:
16747 case CAST:
16748 case TREAT:
16749 case TRIM:
16750 case LEFT:
16751 case RIGHT:
16752 case BOTH:
16753 case EMPTY:
16754 case MULTISET:
16755 case SUBMULTISET:
16756 case LEADING:
16757 case TRAILING:
16758 case CHAR_CS:
16759 case NCHAR_CS:
16760 case DBTIMEZONE:
16761 case SESSIONTIMEZONE:
16762 case AUTHENTICATED:
16763 case LINK:
16764 case SHARED:
16765 case DIRECTORY:
16766 case USER:
16767 case IDENTIFIER:
16768 case UNSIGNED_NUMERIC_LITERAL:
16769 case CHARACTER_LITERAL:
16770 case STRING_LITERAL:
16771 case QUOTED_LITERAL:
16772 simpleNode = ConditionalOrExpression();
16773 sb.append(simpleNode.getImage());
16774 break;
16775 case CC_IF:
16776 simpleNode = CompilationExpression();
16777 sb.append(simpleNode.getImage());
16778 break;
16779 default:
16780 jj_la1[213] = jj_gen;
16781 jj_consume_token(-1);
16782 throw new ParseException();
16783 }
16784 }
16785 jjtree.closeNodeScope(jjtn000, true);
16786 jjtc000 = false;
16787 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16788 } catch (Throwable jjte000) {
16789 if (jjtc000) {
16790 jjtree.clearNodeScope(jjtn000);
16791 jjtc000 = false;
16792 } else {
16793 jjtree.popNode();
16794 }
16795 if (jjte000 instanceof RuntimeException) {
16796 {if (true) throw (RuntimeException)jjte000;}
16797 }
16798 if (jjte000 instanceof ParseException) {
16799 {if (true) throw (ParseException)jjte000;}
16800 }
16801 {if (true) throw (Error)jjte000;}
16802 } finally {
16803 if (jjtc000) {
16804 jjtree.closeNodeScope(jjtn000, true);
16805 }
16806 }
16807 throw new Error("Missing return statement in function");
16808 }
16809
16810 final public ASTCompilationExpression CompilationExpression() throws ParseException {
16811
16812 ASTCompilationExpression jjtn000 = new ASTCompilationExpression(this, JJTCOMPILATIONEXPRESSION);
16813 boolean jjtc000 = true;
16814 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
16815 StringBuilder sb = new StringBuilder() ;
16816 try {
16817 jj_consume_token(CC_IF);
16818 sb.append(" "); sb.append(token.image) ;
16819 simpleNode = ConditionalOrExpression();
16820 sb.append(" "); sb.append(simpleNode.getImage());
16821 jj_consume_token(CC_THEN);
16822 sb.append(" "); sb.append(token.image);
16823 simpleNode = Expression();
16824 sb.append(" "); sb.append(simpleNode.getImage());
16825 label_49:
16826 while (true) {
16827 switch (jj_nt.kind) {
16828 case CC_ELSIF:
16829 ;
16830 break;
16831 default:
16832 jj_la1[214] = jj_gen;
16833 break label_49;
16834 }
16835 jj_consume_token(CC_ELSIF);
16836 sb.append(" "); sb.append(token.image);
16837 simpleNode = ConditionalOrExpression();
16838 sb.append(" "); sb.append(simpleNode.getImage());
16839 jj_consume_token(CC_THEN);
16840 sb.append(" "); sb.append(token.image);
16841 simpleNode = Expression();
16842 sb.append(" "); sb.append(simpleNode.getImage());
16843 }
16844 label_50:
16845 while (true) {
16846 switch (jj_nt.kind) {
16847 case CC_ELSE:
16848 ;
16849 break;
16850 default:
16851 jj_la1[215] = jj_gen;
16852 break label_50;
16853 }
16854 jj_consume_token(CC_ELSE);
16855 sb.append(" "); sb.append(token.image);
16856 simpleNode = Expression();
16857 sb.append(" "); sb.append(simpleNode.getImage());
16858 }
16859 jj_consume_token(CC_END);
16860 sb.append(" "); sb.append(token.image);
16861 jjtree.closeNodeScope(jjtn000, true);
16862 jjtc000 = false;
16863 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16864 } catch (Throwable jjte000) {
16865 if (jjtc000) {
16866 jjtree.clearNodeScope(jjtn000);
16867 jjtc000 = false;
16868 } else {
16869 jjtree.popNode();
16870 }
16871 if (jjte000 instanceof RuntimeException) {
16872 {if (true) throw (RuntimeException)jjte000;}
16873 }
16874 if (jjte000 instanceof ParseException) {
16875 {if (true) throw (ParseException)jjte000;}
16876 }
16877 {if (true) throw (Error)jjte000;}
16878 } finally {
16879 if (jjtc000) {
16880 jjtree.closeNodeScope(jjtn000, true);
16881 }
16882 }
16883 throw new Error("Missing return statement in function");
16884 }
16885
16886 final public ASTAssignment Assignment() throws ParseException {
16887
16888 ASTAssignment jjtn000 = new ASTAssignment(this, JJTASSIGNMENT);
16889 boolean jjtc000 = true;
16890 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
16891 try {
16892 simpleNode = PrimaryExpression();
16893 sb.append(simpleNode.getImage());
16894 jj_consume_token(9);
16895 jj_consume_token(10);
16896 sb.append(" := ");
16897 simpleNode = Expression();
16898 sb.append(simpleNode.getImage());
16899 jjtree.closeNodeScope(jjtn000, true);
16900 jjtc000 = false;
16901 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16902 } catch (Throwable jjte000) {
16903 if (jjtc000) {
16904 jjtree.clearNodeScope(jjtn000);
16905 jjtc000 = false;
16906 } else {
16907 jjtree.popNode();
16908 }
16909 if (jjte000 instanceof RuntimeException) {
16910 {if (true) throw (RuntimeException)jjte000;}
16911 }
16912 if (jjte000 instanceof ParseException) {
16913 {if (true) throw (ParseException)jjte000;}
16914 }
16915 {if (true) throw (Error)jjte000;}
16916 } finally {
16917 if (jjtc000) {
16918 jjtree.closeNodeScope(jjtn000, true);
16919 }
16920 }
16921 throw new Error("Missing return statement in function");
16922 }
16923
16924 final public ASTCaseExpression CaseExpression() throws ParseException {
16925
16926 ASTCaseExpression jjtn000 = new ASTCaseExpression(this, JJTCASEEXPRESSION);
16927 boolean jjtc000 = true;
16928 jjtree.openNodeScope(jjtn000);Token thisToken; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
16929 try {
16930 thisToken = jj_consume_token(CASE);
16931 sb.append(thisToken.image);
16932 switch (jj_nt.kind) {
16933 case 5:
16934 case 16:
16935 case 17:
16936 case REPLACE:
16937 case DEFINER:
16938 case CURRENT_USER:
16939 case LANGUAGE:
16940 case INLINE:
16941 case ADD:
16942 case AGGREGATE:
16943 case ARRAY:
16944 case AT:
16945 case ATTRIBUTE:
16946 case AUTHID:
16947 case BODY:
16948 case BULK:
16949 case BYTE:
16950 case CASCADE:
16951 case CASE:
16952 case CLOSE:
16953 case COALESCE:
16954 case COLLECT:
16955 case COLUMN:
16956 case COMMENT:
16957 case COMMIT:
16958 case CONSTRUCTOR:
16959 case CONTINUE:
16960 case CONVERT:
16961 case CURRENT:
16962 case CURSOR:
16963 case DATA:
16964 case DATE:
16965 case DAY:
16966 case DISABLE:
16967 case EDITIONABLE:
16968 case ELEMENT:
16969 case ENABLE:
16970 case ESCAPE:
16971 case EXCEPT:
16972 case EXCEPTIONS:
16973 case EXIT:
16974 case EXTERNAL:
16975 case EXTENDS:
16976 case EXTRACT:
16977 case FALSE:
16978 case FINAL:
16979 case FORCE:
16980 case FUNCTION:
16981 case GLOBAL:
16982 case HASH:
16983 case HEAP:
16984 case HOUR:
16985 case IMMEDIATE:
16986 case INDICES:
16987 case INDEXTYPE:
16988 case INDICATOR:
16989 case INSTANTIABLE:
16990 case INTERVAL:
16991 case INVALIDATE:
16992 case ISOLATION:
16993 case JAVA:
16994 case LEVEL:
16995 case LIMIT:
16996 case LOOP:
16997 case MAP:
16998 case MAX:
16999 case MEMBER:
17000 case MERGE:
17001 case MIN:
17002 case MINUTE:
17003 case MLSLABEL:
17004 case MODIFY:
17005 case MOD:
17006 case MONTH:
17007 case NATURAL:
17008 case NEW:
17009 case NEW_DOT:
17010 case NO:
17011 case NONEDITIONABLE:
17012 case NOT:
17013 case NULL:
17014 case NULLIF:
17015 case OBJECT:
17016 case OID:
17017 case OPAQUE:
17018 case OPEN:
17019 case OPERATOR:
17020 case ORGANIZATION:
17021 case OTHERS:
17022 case OVERRIDING:
17023 case PACKAGE:
17024 case PARTITION:
17025 case PRESERVE:
17026 case PRIVATE:
17027 case PROCEDURE:
17028 case RANGE:
17029 case RAW:
17030 case REAL:
17031 case RECORD:
17032 case REF:
17033 case RELEASE:
17034 case RELIES_ON:
17035 case RENAME:
17036 case RESULT:
17037 case RETURN:
17038 case RETURNING:
17039 case REVERSE:
17040 case ROLLBACK:
17041 case ROW:
17042 case ROWS:
17043 case ROWID:
17044 case ROWNUM:
17045 case SAVE:
17046 case SAVEPOINT:
17047 case SECOND:
17048 case SELECT:
17049 case SELF:
17050 case SET:
17051 case SPACE:
17052 case SQL:
17053 case SQLCODE:
17054 case SQLERRM:
17055 case STATIC:
17056 case SUBTYPE:
17057 case SUBSTITUTABLE:
17058 case SUCCESSFUL:
17059 case SYSDATE:
17060 case SYS_REFCURSOR:
17061 case TEMPORARY:
17062 case TIME:
17063 case TIMESTAMP:
17064 case TIMEZONE_REGION:
17065 case TIMEZONE_ABBR:
17066 case TIMEZONE_MINUTE:
17067 case TIMEZONE_HOUR:
17068 case TRANSACTION:
17069 case TRUE:
17070 case TYPE:
17071 case UNDER:
17072 case USING:
17073 case YES:
17074 case SHOW:
17075 case A:
17076 case DOUBLE:
17077 case DEC:
17078 case PRECISION:
17079 case INT:
17080 case NUMERIC:
17081 case NCHAR:
17082 case NVARCHAR2:
17083 case STRING:
17084 case UROWID:
17085 case VARRAY:
17086 case VARYING:
17087 case BFILE:
17088 case BLOB:
17089 case CLOB:
17090 case NCLOB:
17091 case YEAR:
17092 case LOCAL:
17093 case WITH:
17094 case ZONE:
17095 case CHARACTER:
17096 case AFTER:
17097 case BEFORE:
17098 case OLD:
17099 case PARENT:
17100 case CC_IF:
17101 case ANALYZE:
17102 case ASSOCIATE:
17103 case AUDIT:
17104 case COMPOUND:
17105 case DATABASE:
17106 case CALL:
17107 case DDL:
17108 case DISASSOCIATE:
17109 case EACH:
17110 case FOLLOWS:
17111 case LOGOFF:
17112 case LOGON:
17113 case NESTED:
17114 case NOAUDIT:
17115 case SCHEMA:
17116 case SERVERERROR:
17117 case SHUTDOWN:
17118 case STARTUP:
17119 case STATEMENT:
17120 case STATISTICS:
17121 case SUSPEND:
17122 case TRUNCATE:
17123 case WRAPPED:
17124 case LIBRARY:
17125 case NAME:
17126 case STRUCT:
17127 case CONTEXT:
17128 case PARAMETERS:
17129 case LENGTH:
17130 case TDO:
17131 case MAXLEN:
17132 case CHARSETID:
17133 case CHARSETFORM:
17134 case ACCEPT:
17135 case ACCESSIBLE:
17136 case COPY:
17137 case DEFINE:
17138 case DISCONNECT:
17139 case HOST:
17140 case PRINT:
17141 case QUIT:
17142 case REMARK:
17143 case UNDEFINE:
17144 case VARIABLE:
17145 case WHENEVER:
17146 case ATTACH:
17147 case CAST:
17148 case TREAT:
17149 case TRIM:
17150 case LEFT:
17151 case RIGHT:
17152 case BOTH:
17153 case EMPTY:
17154 case MULTISET:
17155 case SUBMULTISET:
17156 case LEADING:
17157 case TRAILING:
17158 case CHAR_CS:
17159 case NCHAR_CS:
17160 case DBTIMEZONE:
17161 case SESSIONTIMEZONE:
17162 case AUTHENTICATED:
17163 case LINK:
17164 case SHARED:
17165 case DIRECTORY:
17166 case USER:
17167 case IDENTIFIER:
17168 case UNSIGNED_NUMERIC_LITERAL:
17169 case CHARACTER_LITERAL:
17170 case STRING_LITERAL:
17171 case QUOTED_LITERAL:
17172 simpleNode = Expression();
17173 sb.append(" "); sb.append(simpleNode.getImage());
17174 break;
17175 default:
17176 jj_la1[216] = jj_gen;
17177 ;
17178 }
17179 label_51:
17180 while (true) {
17181 thisToken = jj_consume_token(WHEN);
17182 sb.append(" "); sb.append(thisToken.image);
17183 simpleNode = Expression();
17184 sb.append(" "); sb.append(simpleNode.getImage());
17185 thisToken = jj_consume_token(THEN);
17186 sb.append(" "); sb.append(thisToken.image);
17187 Expression();
17188 sb.append(" "); sb.append(simpleNode.getImage());
17189 switch (jj_nt.kind) {
17190 case WHEN:
17191 ;
17192 break;
17193 default:
17194 jj_la1[217] = jj_gen;
17195 break label_51;
17196 }
17197 }
17198 switch (jj_nt.kind) {
17199 case ELSE:
17200 thisToken = jj_consume_token(ELSE);
17201 sb.append(" "); sb.append(thisToken.image);
17202 Expression();
17203 sb.append(" "); sb.append(simpleNode.getImage());
17204 break;
17205 default:
17206 jj_la1[218] = jj_gen;
17207 ;
17208 }
17209 thisToken = jj_consume_token(END);
17210 sb.append(" "); sb.append(thisToken.image);
17211 jjtree.closeNodeScope(jjtn000, true);
17212 jjtc000 = false;
17213 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17214 } catch (Throwable jjte000) {
17215 if (jjtc000) {
17216 jjtree.clearNodeScope(jjtn000);
17217 jjtc000 = false;
17218 } else {
17219 jjtree.popNode();
17220 }
17221 if (jjte000 instanceof RuntimeException) {
17222 {if (true) throw (RuntimeException)jjte000;}
17223 }
17224 if (jjte000 instanceof ParseException) {
17225 {if (true) throw (ParseException)jjte000;}
17226 }
17227 {if (true) throw (Error)jjte000;}
17228 } finally {
17229 if (jjtc000) {
17230 jjtree.closeNodeScope(jjtn000, true);
17231 }
17232 }
17233 throw new Error("Missing return statement in function");
17234 }
17235
17236
17237
17238
17239 final public ASTLikeExpression LikeExpression() throws ParseException {
17240
17241 ASTLikeExpression jjtn000 = new ASTLikeExpression(this, JJTLIKEEXPRESSION);
17242 boolean jjtc000 = true;
17243 jjtree.openNodeScope(jjtn000);Token thisToken; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17244 try {
17245 simpleNode = PrimaryExpression();
17246 sb.append(" "); sb.append(simpleNode.getImage());
17247 thisToken = jj_consume_token(LIKE);
17248 sb.append(thisToken.image);
17249 simpleNode = StringExpression();
17250 sb.append(" "); sb.append(simpleNode.getImage());
17251 switch (jj_nt.kind) {
17252 case ESCAPE:
17253 jj_consume_token(ESCAPE);
17254 sb.append(" ESCAPE ");
17255 switch (jj_nt.kind) {
17256 case CHARACTER_LITERAL:
17257 jj_consume_token(CHARACTER_LITERAL);
17258 sb.append(" "); sb.append(token.toString());
17259 break;
17260 case STRING_LITERAL:
17261 simpleNode = StringLiteral();
17262 sb.append(" "); sb.append(simpleNode.getImage());
17263 break;
17264 default:
17265 jj_la1[219] = jj_gen;
17266 jj_consume_token(-1);
17267 throw new ParseException();
17268 }
17269 break;
17270 default:
17271 jj_la1[220] = jj_gen;
17272 ;
17273 }
17274 label_52:
17275 while (true) {
17276 switch (jj_nt.kind) {
17277 case 3:
17278 ;
17279 break;
17280 default:
17281 jj_la1[221] = jj_gen;
17282 break label_52;
17283 }
17284 jj_consume_token(3);
17285 simpleNode = Expression();
17286 sb.append("."); sb.append(simpleNode.getImage());
17287 }
17288 jjtree.closeNodeScope(jjtn000, true);
17289 jjtc000 = false;
17290 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17291 } catch (Throwable jjte000) {
17292 if (jjtc000) {
17293 jjtree.clearNodeScope(jjtn000);
17294 jjtc000 = false;
17295 } else {
17296 jjtree.popNode();
17297 }
17298 if (jjte000 instanceof RuntimeException) {
17299 {if (true) throw (RuntimeException)jjte000;}
17300 }
17301 if (jjte000 instanceof ParseException) {
17302 {if (true) throw (ParseException)jjte000;}
17303 }
17304 {if (true) throw (Error)jjte000;}
17305 } finally {
17306 if (jjtc000) {
17307 jjtree.closeNodeScope(jjtn000, true);
17308 }
17309 }
17310 throw new Error("Missing return statement in function");
17311 }
17312
17313 final public ASTTrimExpression TrimExpression() throws ParseException {
17314
17315 ASTTrimExpression jjtn000 = new ASTTrimExpression(this, JJTTRIMEXPRESSION);
17316 boolean jjtc000 = true;
17317 jjtree.openNodeScope(jjtn000);Token thisToken; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17318 try {
17319 thisToken = jj_consume_token(TRIM);
17320 sb.append(thisToken.image);
17321 jj_consume_token(5);
17322 sb.append("(");
17323 switch (jj_nt.kind) {
17324 case BOTH:
17325 case LEADING:
17326 case TRAILING:
17327 switch (jj_nt.kind) {
17328 case LEADING:
17329 jj_consume_token(LEADING);
17330 break;
17331 case TRAILING:
17332 jj_consume_token(TRAILING);
17333 break;
17334 case BOTH:
17335 jj_consume_token(BOTH);
17336 break;
17337 default:
17338 jj_la1[222] = jj_gen;
17339 jj_consume_token(-1);
17340 throw new ParseException();
17341 }
17342 sb.append(" "); sb.append(token.toString());
17343 break;
17344 default:
17345 jj_la1[223] = jj_gen;
17346 ;
17347 }
17348 switch (jj_nt.kind) {
17349 case 5:
17350 case REPLACE:
17351 case DEFINER:
17352 case CURRENT_USER:
17353 case LANGUAGE:
17354 case INLINE:
17355 case ADD:
17356 case AGGREGATE:
17357 case ARRAY:
17358 case AT:
17359 case ATTRIBUTE:
17360 case AUTHID:
17361 case BODY:
17362 case BULK:
17363 case BYTE:
17364 case CASCADE:
17365 case CASE:
17366 case CLOSE:
17367 case COALESCE:
17368 case COLLECT:
17369 case COLUMN:
17370 case COMMENT:
17371 case COMMIT:
17372 case CONSTRUCTOR:
17373 case CONTINUE:
17374 case CONVERT:
17375 case CURRENT:
17376 case CURSOR:
17377 case DATA:
17378 case DATE:
17379 case DAY:
17380 case DISABLE:
17381 case EDITIONABLE:
17382 case ELEMENT:
17383 case ENABLE:
17384 case ESCAPE:
17385 case EXCEPT:
17386 case EXCEPTIONS:
17387 case EXIT:
17388 case EXTERNAL:
17389 case EXTENDS:
17390 case EXTRACT:
17391 case FALSE:
17392 case FINAL:
17393 case FORCE:
17394 case FUNCTION:
17395 case GLOBAL:
17396 case HASH:
17397 case HEAP:
17398 case HOUR:
17399 case IMMEDIATE:
17400 case INDICES:
17401 case INDEXTYPE:
17402 case INDICATOR:
17403 case INSTANTIABLE:
17404 case INTERVAL:
17405 case INVALIDATE:
17406 case ISOLATION:
17407 case JAVA:
17408 case LEVEL:
17409 case LIMIT:
17410 case LOOP:
17411 case MAP:
17412 case MAX:
17413 case MEMBER:
17414 case MERGE:
17415 case MIN:
17416 case MINUTE:
17417 case MLSLABEL:
17418 case MODIFY:
17419 case MOD:
17420 case MONTH:
17421 case NATURAL:
17422 case NEW:
17423 case NEW_DOT:
17424 case NO:
17425 case NONEDITIONABLE:
17426 case NULL:
17427 case NULLIF:
17428 case OBJECT:
17429 case OID:
17430 case OPAQUE:
17431 case OPEN:
17432 case OPERATOR:
17433 case ORGANIZATION:
17434 case OTHERS:
17435 case OVERRIDING:
17436 case PACKAGE:
17437 case PARTITION:
17438 case PRESERVE:
17439 case PRIVATE:
17440 case PROCEDURE:
17441 case RANGE:
17442 case RAW:
17443 case REAL:
17444 case RECORD:
17445 case REF:
17446 case RELEASE:
17447 case RELIES_ON:
17448 case RENAME:
17449 case RESULT:
17450 case RETURN:
17451 case RETURNING:
17452 case REVERSE:
17453 case ROLLBACK:
17454 case ROW:
17455 case ROWS:
17456 case ROWID:
17457 case ROWNUM:
17458 case SAVE:
17459 case SAVEPOINT:
17460 case SECOND:
17461 case SELECT:
17462 case SELF:
17463 case SET:
17464 case SPACE:
17465 case SQL:
17466 case SQLCODE:
17467 case SQLERRM:
17468 case STATIC:
17469 case SUBTYPE:
17470 case SUBSTITUTABLE:
17471 case SUCCESSFUL:
17472 case SYSDATE:
17473 case SYS_REFCURSOR:
17474 case TEMPORARY:
17475 case TIME:
17476 case TIMESTAMP:
17477 case TIMEZONE_REGION:
17478 case TIMEZONE_ABBR:
17479 case TIMEZONE_MINUTE:
17480 case TIMEZONE_HOUR:
17481 case TRANSACTION:
17482 case TRUE:
17483 case TYPE:
17484 case UNDER:
17485 case USING:
17486 case YES:
17487 case SHOW:
17488 case A:
17489 case DOUBLE:
17490 case DEC:
17491 case PRECISION:
17492 case INT:
17493 case NUMERIC:
17494 case NCHAR:
17495 case NVARCHAR2:
17496 case STRING:
17497 case UROWID:
17498 case VARRAY:
17499 case VARYING:
17500 case BFILE:
17501 case BLOB:
17502 case CLOB:
17503 case NCLOB:
17504 case YEAR:
17505 case LOCAL:
17506 case WITH:
17507 case ZONE:
17508 case CHARACTER:
17509 case AFTER:
17510 case BEFORE:
17511 case OLD:
17512 case PARENT:
17513 case ANALYZE:
17514 case ASSOCIATE:
17515 case AUDIT:
17516 case COMPOUND:
17517 case DATABASE:
17518 case CALL:
17519 case DDL:
17520 case DISASSOCIATE:
17521 case EACH:
17522 case FOLLOWS:
17523 case LOGOFF:
17524 case LOGON:
17525 case NESTED:
17526 case NOAUDIT:
17527 case SCHEMA:
17528 case SERVERERROR:
17529 case SHUTDOWN:
17530 case STARTUP:
17531 case STATEMENT:
17532 case STATISTICS:
17533 case SUSPEND:
17534 case TRUNCATE:
17535 case WRAPPED:
17536 case LIBRARY:
17537 case NAME:
17538 case STRUCT:
17539 case CONTEXT:
17540 case PARAMETERS:
17541 case LENGTH:
17542 case TDO:
17543 case MAXLEN:
17544 case CHARSETID:
17545 case CHARSETFORM:
17546 case ACCEPT:
17547 case ACCESSIBLE:
17548 case COPY:
17549 case DEFINE:
17550 case DISCONNECT:
17551 case HOST:
17552 case PRINT:
17553 case QUIT:
17554 case REMARK:
17555 case UNDEFINE:
17556 case VARIABLE:
17557 case WHENEVER:
17558 case ATTACH:
17559 case CAST:
17560 case TREAT:
17561 case TRIM:
17562 case LEFT:
17563 case RIGHT:
17564 case BOTH:
17565 case EMPTY:
17566 case MULTISET:
17567 case SUBMULTISET:
17568 case LEADING:
17569 case TRAILING:
17570 case CHAR_CS:
17571 case NCHAR_CS:
17572 case DBTIMEZONE:
17573 case SESSIONTIMEZONE:
17574 case AUTHENTICATED:
17575 case LINK:
17576 case SHARED:
17577 case DIRECTORY:
17578 case USER:
17579 case IDENTIFIER:
17580 case UNSIGNED_NUMERIC_LITERAL:
17581 case CHARACTER_LITERAL:
17582 case STRING_LITERAL:
17583 case QUOTED_LITERAL:
17584 simpleNode = StringExpression();
17585 sb.append(" "); sb.append(simpleNode.getImage());
17586 break;
17587 default:
17588 jj_la1[224] = jj_gen;
17589 ;
17590 }
17591 jj_consume_token(FROM);
17592 sb.append(thisToken.image);
17593 simpleNode = StringExpression();
17594 sb.append(" "); sb.append(simpleNode.getImage());
17595 jj_consume_token(7);
17596 sb.append(")");
17597 jjtree.closeNodeScope(jjtn000, true);
17598 jjtc000 = false;
17599 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17600 } catch (Throwable jjte000) {
17601 if (jjtc000) {
17602 jjtree.clearNodeScope(jjtn000);
17603 jjtc000 = false;
17604 } else {
17605 jjtree.popNode();
17606 }
17607 if (jjte000 instanceof RuntimeException) {
17608 {if (true) throw (RuntimeException)jjte000;}
17609 }
17610 if (jjte000 instanceof ParseException) {
17611 {if (true) throw (ParseException)jjte000;}
17612 }
17613 {if (true) throw (Error)jjte000;}
17614 } finally {
17615 if (jjtc000) {
17616 jjtree.closeNodeScope(jjtn000, true);
17617 }
17618 }
17619 throw new Error("Missing return statement in function");
17620 }
17621
17622
17623
17624
17625
17626 final public ASTObjectExpression ObjectExpression() throws ParseException {
17627
17628 ASTObjectExpression jjtn000 = new ASTObjectExpression(this, JJTOBJECTEXPRESSION);
17629 boolean jjtc000 = true;
17630 jjtree.openNodeScope(jjtn000);Token thisToken; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17631 try {
17632 switch (jj_nt.kind) {
17633 case CAST:
17634 thisToken = jj_consume_token(CAST);
17635 break;
17636 case TREAT:
17637 thisToken = jj_consume_token(TREAT);
17638 break;
17639 default:
17640 jj_la1[225] = jj_gen;
17641 jj_consume_token(-1);
17642 throw new ParseException();
17643 }
17644 sb.append(thisToken.image);
17645 jj_consume_token(5);
17646 sb.append("(");
17647 simpleNode = Expression();
17648 sb.append(" "); sb.append(simpleNode.getImage());
17649 switch (jj_nt.kind) {
17650 case AT:
17651 jj_consume_token(AT);
17652 jj_consume_token(TIME);
17653 jj_consume_token(ZONE);
17654 simpleNode = PrimaryExpression();
17655 sb.append(" AT TIME ZONE "); sb.append(simpleNode.getImage());
17656 break;
17657 default:
17658 jj_la1[226] = jj_gen;
17659 ;
17660 }
17661 jj_consume_token(AS);
17662 sb.append(" AS ");
17663 simpleNode = Datatype();
17664 sb.append(" "); sb.append(simpleNode.getImage());
17665 jj_consume_token(7);
17666 sb.append(")");
17667 label_53:
17668 while (true) {
17669 switch (jj_nt.kind) {
17670 case 3:
17671 ;
17672 break;
17673 default:
17674 jj_la1[227] = jj_gen;
17675 break label_53;
17676 }
17677 jj_consume_token(3);
17678 Expression();
17679 }
17680 jjtree.closeNodeScope(jjtn000, true);
17681 jjtc000 = false;
17682 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17683 } catch (Throwable jjte000) {
17684 if (jjtc000) {
17685 jjtree.clearNodeScope(jjtn000);
17686 jjtc000 = false;
17687 } else {
17688 jjtree.popNode();
17689 }
17690 if (jjte000 instanceof RuntimeException) {
17691 {if (true) throw (RuntimeException)jjte000;}
17692 }
17693 if (jjte000 instanceof ParseException) {
17694 {if (true) throw (ParseException)jjte000;}
17695 }
17696 {if (true) throw (Error)jjte000;}
17697 } finally {
17698 if (jjtc000) {
17699 jjtree.closeNodeScope(jjtn000, true);
17700 }
17701 }
17702 throw new Error("Missing return statement in function");
17703 }
17704
17705 final public ASTConditionalOrExpression ConditionalOrExpression() throws ParseException {
17706
17707 ASTConditionalOrExpression jjtn000 = new ASTConditionalOrExpression(this, JJTCONDITIONALOREXPRESSION);
17708 boolean jjtc000 = true;
17709 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17710 try {
17711 simpleNode = ConditionalAndExpression();
17712 sb.append(simpleNode.getImage());
17713 label_54:
17714 while (true) {
17715 switch (jj_nt.kind) {
17716 case OR:
17717 ;
17718 break;
17719 default:
17720 jj_la1[228] = jj_gen;
17721 break label_54;
17722 }
17723 jj_consume_token(OR);
17724 sb.append(" OR ");
17725 simpleNode = ConditionalAndExpression();
17726 sb.append(simpleNode.getImage());
17727 }
17728 jjtree.closeNodeScope(jjtn000, true);
17729 jjtc000 = false;
17730 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17731 } catch (Throwable jjte000) {
17732 if (jjtc000) {
17733 jjtree.clearNodeScope(jjtn000);
17734 jjtc000 = false;
17735 } else {
17736 jjtree.popNode();
17737 }
17738 if (jjte000 instanceof RuntimeException) {
17739 {if (true) throw (RuntimeException)jjte000;}
17740 }
17741 if (jjte000 instanceof ParseException) {
17742 {if (true) throw (ParseException)jjte000;}
17743 }
17744 {if (true) throw (Error)jjte000;}
17745 } finally {
17746 if (jjtc000) {
17747 jjtree.closeNodeScope(jjtn000, true);
17748 }
17749 }
17750 throw new Error("Missing return statement in function");
17751 }
17752
17753 final public ASTConditionalAndExpression ConditionalAndExpression() throws ParseException {
17754
17755 ASTConditionalAndExpression jjtn000 = new ASTConditionalAndExpression(this, JJTCONDITIONALANDEXPRESSION);
17756 boolean jjtc000 = true;
17757 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17758 try {
17759 simpleNode = EqualityExpression();
17760 sb.append(simpleNode.getImage());
17761 label_55:
17762 while (true) {
17763 switch (jj_nt.kind) {
17764 case AND:
17765 ;
17766 break;
17767 default:
17768 jj_la1[229] = jj_gen;
17769 break label_55;
17770 }
17771 jj_consume_token(AND);
17772 sb.append(" AND ");
17773 simpleNode = EqualityExpression();
17774 sb.append(simpleNode.getImage());
17775 }
17776 jjtree.closeNodeScope(jjtn000, true);
17777 jjtc000 = false;
17778 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17779 } catch (Throwable jjte000) {
17780 if (jjtc000) {
17781 jjtree.clearNodeScope(jjtn000);
17782 jjtc000 = false;
17783 } else {
17784 jjtree.popNode();
17785 }
17786 if (jjte000 instanceof RuntimeException) {
17787 {if (true) throw (RuntimeException)jjte000;}
17788 }
17789 if (jjte000 instanceof ParseException) {
17790 {if (true) throw (ParseException)jjte000;}
17791 }
17792 {if (true) throw (Error)jjte000;}
17793 } finally {
17794 if (jjtc000) {
17795 jjtree.closeNodeScope(jjtn000, true);
17796 }
17797 }
17798 throw new Error("Missing return statement in function");
17799 }
17800
17801 final public ASTEqualityExpression EqualityExpression() throws ParseException {
17802
17803 ASTEqualityExpression jjtn000 = new ASTEqualityExpression(this, JJTEQUALITYEXPRESSION);
17804 boolean jjtc000 = true;
17805 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17806 try {
17807 simpleNode = RelationalExpression();
17808 sb.append(simpleNode.getImage());
17809 label_56:
17810 while (true) {
17811 switch (jj_nt.kind) {
17812 case 10:
17813 case 13:
17814 case IS:
17815 ;
17816 break;
17817 default:
17818 jj_la1[230] = jj_gen;
17819 break label_56;
17820 }
17821 switch (jj_nt.kind) {
17822 case 10:
17823 jj_consume_token(10);
17824 sb.append(" = ");
17825 break;
17826 case 13:
17827 jj_consume_token(13);
17828 jj_consume_token(10);
17829 sb.append(" != ");
17830 break;
17831 case IS:
17832 jj_consume_token(IS);
17833 sb.append(" IS ");
17834 break;
17835 default:
17836 jj_la1[231] = jj_gen;
17837 jj_consume_token(-1);
17838 throw new ParseException();
17839 }
17840 simpleNode = RelationalExpression();
17841 sb.append(simpleNode.getImage());
17842 }
17843 jjtree.closeNodeScope(jjtn000, true);
17844 jjtc000 = false;
17845 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17846 } catch (Throwable jjte000) {
17847 if (jjtc000) {
17848 jjtree.clearNodeScope(jjtn000);
17849 jjtc000 = false;
17850 } else {
17851 jjtree.popNode();
17852 }
17853 if (jjte000 instanceof RuntimeException) {
17854 {if (true) throw (RuntimeException)jjte000;}
17855 }
17856 if (jjte000 instanceof ParseException) {
17857 {if (true) throw (ParseException)jjte000;}
17858 }
17859 {if (true) throw (Error)jjte000;}
17860 } finally {
17861 if (jjtc000) {
17862 jjtree.closeNodeScope(jjtn000, true);
17863 }
17864 }
17865 throw new Error("Missing return statement in function");
17866 }
17867
17868
17869
17870
17871 final public ASTRelationalExpression RelationalExpression() throws ParseException {
17872
17873 ASTRelationalExpression jjtn000 = new ASTRelationalExpression(this, JJTRELATIONALEXPRESSION);
17874 boolean jjtc000 = true;
17875 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17876 try {
17877 simpleNode = AdditiveExpression();
17878 sb.append(simpleNode.getImage());
17879 label_57:
17880 while (true) {
17881 switch (jj_nt.kind) {
17882 case 14:
17883 case 15:
17884 case BETWEEN:
17885 case FROM:
17886 case IN:
17887 case LIKE:
17888 case MEMBER:
17889 case NOT:
17890 case MULTISET:
17891 case SUBMULTISET:
17892 ;
17893 break;
17894 default:
17895 jj_la1[232] = jj_gen;
17896 break label_57;
17897 }
17898 switch (jj_nt.kind) {
17899 case 14:
17900 case 15:
17901 switch (jj_nt.kind) {
17902 case 14:
17903 jj_consume_token(14);
17904 sb.append("<");
17905 switch (jj_nt.kind) {
17906 case 15:
17907 jj_consume_token(15);
17908 sb.append(">");
17909 break;
17910 default:
17911 jj_la1[233] = jj_gen;
17912 ;
17913 }
17914 break;
17915 case 15:
17916 jj_consume_token(15);
17917 sb.append(">");
17918 break;
17919 default:
17920 jj_la1[234] = jj_gen;
17921 jj_consume_token(-1);
17922 throw new ParseException();
17923 }
17924 switch (jj_nt.kind) {
17925 case 10:
17926 jj_consume_token(10);
17927 sb.append("=");
17928 break;
17929 default:
17930 jj_la1[235] = jj_gen;
17931 ;
17932 }
17933 sb.append(" ");
17934 break;
17935 case BETWEEN:
17936 case FROM:
17937 case IN:
17938 case LIKE:
17939 case MEMBER:
17940 case NOT:
17941 case SUBMULTISET:
17942 switch (jj_nt.kind) {
17943 case NOT:
17944 jj_consume_token(NOT);
17945 sb.append(" NOT ");
17946 break;
17947 default:
17948 jj_la1[236] = jj_gen;
17949 ;
17950 }
17951 switch (jj_nt.kind) {
17952 case IN:
17953 jj_consume_token(IN);
17954 sb.append(" IN ");
17955 break;
17956 case BETWEEN:
17957 jj_consume_token(BETWEEN);
17958 sb.append(" BETWEEN ");
17959 break;
17960 case LIKE:
17961 jj_consume_token(LIKE);
17962 sb.append(" LIKE ");
17963 break;
17964 case FROM:
17965 jj_consume_token(FROM);
17966 sb.append(" FROM ");
17967 break;
17968 case MEMBER:
17969 case SUBMULTISET:
17970 switch (jj_nt.kind) {
17971 case MEMBER:
17972 jj_consume_token(MEMBER);
17973 sb.append(" MEMBER ");
17974 break;
17975 case SUBMULTISET:
17976 jj_consume_token(SUBMULTISET);
17977 sb.append(" SUBMULTISET ");
17978 break;
17979 default:
17980 jj_la1[237] = jj_gen;
17981 jj_consume_token(-1);
17982 throw new ParseException();
17983 }
17984 switch (jj_nt.kind) {
17985 case OF:
17986 jj_consume_token(OF);
17987 sb.append(" OF ");
17988 break;
17989 default:
17990 jj_la1[238] = jj_gen;
17991 ;
17992 }
17993 break;
17994 default:
17995 jj_la1[239] = jj_gen;
17996 jj_consume_token(-1);
17997 throw new ParseException();
17998 }
17999 break;
18000 case MULTISET:
18001 jj_consume_token(MULTISET);
18002 sb.append (" MULTISET " );
18003 switch (jj_nt.kind) {
18004 case EXCEPT:
18005 jj_consume_token(EXCEPT);
18006 sb.append (" EXCEPT " );
18007 break;
18008 case INTERSECT:
18009 jj_consume_token(INTERSECT);
18010 sb.append (" INTERSECT " );
18011 break;
18012 case UNION:
18013 jj_consume_token(UNION);
18014 sb.append (" UNION " );
18015 break;
18016 default:
18017 jj_la1[240] = jj_gen;
18018 jj_consume_token(-1);
18019 throw new ParseException();
18020 }
18021 switch (jj_nt.kind) {
18022 case ALL:
18023 case DISTINCT:
18024 switch (jj_nt.kind) {
18025 case DISTINCT:
18026 jj_consume_token(DISTINCT);
18027 sb.append (" DISTINCT " );
18028 break;
18029 case ALL:
18030 jj_consume_token(ALL);
18031 sb.append (" ALL " );
18032 break;
18033 default:
18034 jj_la1[241] = jj_gen;
18035 jj_consume_token(-1);
18036 throw new ParseException();
18037 }
18038 break;
18039 default:
18040 jj_la1[242] = jj_gen;
18041 ;
18042 }
18043 break;
18044 default:
18045 jj_la1[243] = jj_gen;
18046 jj_consume_token(-1);
18047 throw new ParseException();
18048 }
18049 AdditiveExpression();
18050 sb.append(simpleNode.getImage());
18051 switch (jj_nt.kind) {
18052 case ESCAPE:
18053 jj_consume_token(ESCAPE);
18054 sb.append(" ESCAPE ");
18055 switch (jj_nt.kind) {
18056 case CHARACTER_LITERAL:
18057 jj_consume_token(CHARACTER_LITERAL);
18058 sb.append(" "); sb.append(token.toString());
18059 break;
18060 case STRING_LITERAL:
18061 simpleNode = StringLiteral();
18062 sb.append(" "); sb.append(simpleNode.getImage());
18063 break;
18064 default:
18065 jj_la1[244] = jj_gen;
18066 jj_consume_token(-1);
18067 throw new ParseException();
18068 }
18069 break;
18070 default:
18071 jj_la1[245] = jj_gen;
18072 ;
18073 }
18074 }
18075 jjtree.closeNodeScope(jjtn000, true);
18076 jjtc000 = false;
18077 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18078 } catch (Throwable jjte000) {
18079 if (jjtc000) {
18080 jjtree.clearNodeScope(jjtn000);
18081 jjtc000 = false;
18082 } else {
18083 jjtree.popNode();
18084 }
18085 if (jjte000 instanceof RuntimeException) {
18086 {if (true) throw (RuntimeException)jjte000;}
18087 }
18088 if (jjte000 instanceof ParseException) {
18089 {if (true) throw (ParseException)jjte000;}
18090 }
18091 {if (true) throw (Error)jjte000;}
18092 } finally {
18093 if (jjtc000) {
18094 jjtree.closeNodeScope(jjtn000, true);
18095 }
18096 }
18097 throw new Error("Missing return statement in function");
18098 }
18099
18100 final public ASTAdditiveExpression AdditiveExpression() throws ParseException {
18101
18102 ASTAdditiveExpression jjtn000 = new ASTAdditiveExpression(this, JJTADDITIVEEXPRESSION);
18103 boolean jjtc000 = true;
18104 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18105 try {
18106 simpleNode = MultiplicativeExpression();
18107 sb.append(simpleNode.getImage());
18108 label_58:
18109 while (true) {
18110 switch (jj_nt.kind) {
18111 case 16:
18112 case 17:
18113 case 18:
18114 ;
18115 break;
18116 default:
18117 jj_la1[246] = jj_gen;
18118 break label_58;
18119 }
18120 switch (jj_nt.kind) {
18121 case 16:
18122 jj_consume_token(16);
18123 sb.append(" + ");
18124 break;
18125 case 17:
18126 jj_consume_token(17);
18127 sb.append(" - ");
18128 break;
18129 case 18:
18130 jj_consume_token(18);
18131 sb.append(" || ");
18132 break;
18133 default:
18134 jj_la1[247] = jj_gen;
18135 jj_consume_token(-1);
18136 throw new ParseException();
18137 }
18138 simpleNode = MultiplicativeExpression();
18139 sb.append(simpleNode.getImage());
18140 }
18141 jjtree.closeNodeScope(jjtn000, true);
18142 jjtc000 = false;
18143 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18144 } catch (Throwable jjte000) {
18145 if (jjtc000) {
18146 jjtree.clearNodeScope(jjtn000);
18147 jjtc000 = false;
18148 } else {
18149 jjtree.popNode();
18150 }
18151 if (jjte000 instanceof RuntimeException) {
18152 {if (true) throw (RuntimeException)jjte000;}
18153 }
18154 if (jjte000 instanceof ParseException) {
18155 {if (true) throw (ParseException)jjte000;}
18156 }
18157 {if (true) throw (Error)jjte000;}
18158 } finally {
18159 if (jjtc000) {
18160 jjtree.closeNodeScope(jjtn000, true);
18161 }
18162 }
18163 throw new Error("Missing return statement in function");
18164 }
18165
18166 final public ASTStringExpression StringExpression() throws ParseException {
18167
18168 ASTStringExpression jjtn000 = new ASTStringExpression(this, JJTSTRINGEXPRESSION);
18169 boolean jjtc000 = true;
18170 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18171 try {
18172 simpleNode = PrimaryExpression();
18173 sb.append(simpleNode.getImage());
18174 label_59:
18175 while (true) {
18176 switch (jj_nt.kind) {
18177 case 18:
18178 ;
18179 break;
18180 default:
18181 jj_la1[248] = jj_gen;
18182 break label_59;
18183 }
18184 jj_consume_token(18);
18185 sb.append(" || ");
18186 simpleNode = PrimaryExpression();
18187 sb.append(simpleNode.getImage());
18188 }
18189 jjtree.closeNodeScope(jjtn000, true);
18190 jjtc000 = false;
18191 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18192 } catch (Throwable jjte000) {
18193 if (jjtc000) {
18194 jjtree.clearNodeScope(jjtn000);
18195 jjtc000 = false;
18196 } else {
18197 jjtree.popNode();
18198 }
18199 if (jjte000 instanceof RuntimeException) {
18200 {if (true) throw (RuntimeException)jjte000;}
18201 }
18202 if (jjte000 instanceof ParseException) {
18203 {if (true) throw (ParseException)jjte000;}
18204 }
18205 {if (true) throw (Error)jjte000;}
18206 } finally {
18207 if (jjtc000) {
18208 jjtree.closeNodeScope(jjtn000, true);
18209 }
18210 }
18211 throw new Error("Missing return statement in function");
18212 }
18213
18214 final public ASTMultiplicativeExpression MultiplicativeExpression() throws ParseException {
18215
18216 ASTMultiplicativeExpression jjtn000 = new ASTMultiplicativeExpression(this, JJTMULTIPLICATIVEEXPRESSION);
18217 boolean jjtc000 = true;
18218 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18219 try {
18220 simpleNode = UnaryExpression(true);
18221 sb.append(simpleNode.getImage());
18222 label_60:
18223 while (true) {
18224 switch (jj_nt.kind) {
18225 case 1:
18226 case 19:
18227 case 20:
18228 case MOD:
18229 ;
18230 break;
18231 default:
18232 jj_la1[249] = jj_gen;
18233 break label_60;
18234 }
18235 switch (jj_nt.kind) {
18236 case 19:
18237 jj_consume_token(19);
18238 sb.append(" ** ");
18239 break;
18240 case 20:
18241 jj_consume_token(20);
18242 sb.append(" * ");
18243 break;
18244 case 1:
18245 jj_consume_token(1);
18246 sb.append(" / ");
18247 break;
18248 case MOD:
18249 jj_consume_token(MOD);
18250 sb.append(" MOD ");
18251 break;
18252 default:
18253 jj_la1[250] = jj_gen;
18254 jj_consume_token(-1);
18255 throw new ParseException();
18256 }
18257 simpleNode = UnaryExpression(true);
18258 sb.append(simpleNode.getImage());
18259 }
18260 jjtree.closeNodeScope(jjtn000, true);
18261 jjtc000 = false;
18262 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18263 } catch (Throwable jjte000) {
18264 if (jjtc000) {
18265 jjtree.clearNodeScope(jjtn000);
18266 jjtc000 = false;
18267 } else {
18268 jjtree.popNode();
18269 }
18270 if (jjte000 instanceof RuntimeException) {
18271 {if (true) throw (RuntimeException)jjte000;}
18272 }
18273 if (jjte000 instanceof ParseException) {
18274 {if (true) throw (ParseException)jjte000;}
18275 }
18276 {if (true) throw (Error)jjte000;}
18277 } finally {
18278 if (jjtc000) {
18279 jjtree.closeNodeScope(jjtn000, true);
18280 }
18281 }
18282 throw new Error("Missing return statement in function");
18283 }
18284
18285 final public ASTUnaryExpression UnaryExpression(boolean isUnarySign) throws ParseException {
18286
18287 ASTUnaryExpression jjtn000 = new ASTUnaryExpression(this, JJTUNARYEXPRESSION);
18288 boolean jjtc000 = true;
18289 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18290 try {
18291 switch (jj_nt.kind) {
18292 case 16:
18293 case 17:
18294 switch (jj_nt.kind) {
18295 case 16:
18296 jj_consume_token(16);
18297 sb.append(isUnarySign ? " +" : " + ");
18298 break;
18299 case 17:
18300 jj_consume_token(17);
18301 sb.append(isUnarySign ? " -" : " - ");
18302 break;
18303 default:
18304 jj_la1[251] = jj_gen;
18305 jj_consume_token(-1);
18306 throw new ParseException();
18307 }
18308 simpleNode = UnaryExpression(false);
18309 sb.append(simpleNode.getImage());
18310 break;
18311 case 5:
18312 case REPLACE:
18313 case DEFINER:
18314 case CURRENT_USER:
18315 case LANGUAGE:
18316 case INLINE:
18317 case ADD:
18318 case AGGREGATE:
18319 case ARRAY:
18320 case AT:
18321 case ATTRIBUTE:
18322 case AUTHID:
18323 case BODY:
18324 case BULK:
18325 case BYTE:
18326 case CASCADE:
18327 case CASE:
18328 case CLOSE:
18329 case COALESCE:
18330 case COLLECT:
18331 case COLUMN:
18332 case COMMENT:
18333 case COMMIT:
18334 case CONSTRUCTOR:
18335 case CONTINUE:
18336 case CONVERT:
18337 case CURRENT:
18338 case CURSOR:
18339 case DATA:
18340 case DATE:
18341 case DAY:
18342 case DISABLE:
18343 case EDITIONABLE:
18344 case ELEMENT:
18345 case ENABLE:
18346 case ESCAPE:
18347 case EXCEPT:
18348 case EXCEPTIONS:
18349 case EXIT:
18350 case EXTERNAL:
18351 case EXTENDS:
18352 case EXTRACT:
18353 case FALSE:
18354 case FINAL:
18355 case FORCE:
18356 case FUNCTION:
18357 case GLOBAL:
18358 case HASH:
18359 case HEAP:
18360 case HOUR:
18361 case IMMEDIATE:
18362 case INDICES:
18363 case INDEXTYPE:
18364 case INDICATOR:
18365 case INSTANTIABLE:
18366 case INTERVAL:
18367 case INVALIDATE:
18368 case ISOLATION:
18369 case JAVA:
18370 case LEVEL:
18371 case LIMIT:
18372 case LOOP:
18373 case MAP:
18374 case MAX:
18375 case MEMBER:
18376 case MERGE:
18377 case MIN:
18378 case MINUTE:
18379 case MLSLABEL:
18380 case MODIFY:
18381 case MOD:
18382 case MONTH:
18383 case NATURAL:
18384 case NEW:
18385 case NEW_DOT:
18386 case NO:
18387 case NONEDITIONABLE:
18388 case NOT:
18389 case NULL:
18390 case NULLIF:
18391 case OBJECT:
18392 case OID:
18393 case OPAQUE:
18394 case OPEN:
18395 case OPERATOR:
18396 case ORGANIZATION:
18397 case OTHERS:
18398 case OVERRIDING:
18399 case PACKAGE:
18400 case PARTITION:
18401 case PRESERVE:
18402 case PRIVATE:
18403 case PROCEDURE:
18404 case RANGE:
18405 case RAW:
18406 case REAL:
18407 case RECORD:
18408 case REF:
18409 case RELEASE:
18410 case RELIES_ON:
18411 case RENAME:
18412 case RESULT:
18413 case RETURN:
18414 case RETURNING:
18415 case REVERSE:
18416 case ROLLBACK:
18417 case ROW:
18418 case ROWS:
18419 case ROWID:
18420 case ROWNUM:
18421 case SAVE:
18422 case SAVEPOINT:
18423 case SECOND:
18424 case SELECT:
18425 case SELF:
18426 case SET:
18427 case SPACE:
18428 case SQL:
18429 case SQLCODE:
18430 case SQLERRM:
18431 case STATIC:
18432 case SUBTYPE:
18433 case SUBSTITUTABLE:
18434 case SUCCESSFUL:
18435 case SYSDATE:
18436 case SYS_REFCURSOR:
18437 case TEMPORARY:
18438 case TIME:
18439 case TIMESTAMP:
18440 case TIMEZONE_REGION:
18441 case TIMEZONE_ABBR:
18442 case TIMEZONE_MINUTE:
18443 case TIMEZONE_HOUR:
18444 case TRANSACTION:
18445 case TRUE:
18446 case TYPE:
18447 case UNDER:
18448 case USING:
18449 case YES:
18450 case SHOW:
18451 case A:
18452 case DOUBLE:
18453 case DEC:
18454 case PRECISION:
18455 case INT:
18456 case NUMERIC:
18457 case NCHAR:
18458 case NVARCHAR2:
18459 case STRING:
18460 case UROWID:
18461 case VARRAY:
18462 case VARYING:
18463 case BFILE:
18464 case BLOB:
18465 case CLOB:
18466 case NCLOB:
18467 case YEAR:
18468 case LOCAL:
18469 case WITH:
18470 case ZONE:
18471 case CHARACTER:
18472 case AFTER:
18473 case BEFORE:
18474 case OLD:
18475 case PARENT:
18476 case ANALYZE:
18477 case ASSOCIATE:
18478 case AUDIT:
18479 case COMPOUND:
18480 case DATABASE:
18481 case CALL:
18482 case DDL:
18483 case DISASSOCIATE:
18484 case EACH:
18485 case FOLLOWS:
18486 case LOGOFF:
18487 case LOGON:
18488 case NESTED:
18489 case NOAUDIT:
18490 case SCHEMA:
18491 case SERVERERROR:
18492 case SHUTDOWN:
18493 case STARTUP:
18494 case STATEMENT:
18495 case STATISTICS:
18496 case SUSPEND:
18497 case TRUNCATE:
18498 case WRAPPED:
18499 case LIBRARY:
18500 case NAME:
18501 case STRUCT:
18502 case CONTEXT:
18503 case PARAMETERS:
18504 case LENGTH:
18505 case TDO:
18506 case MAXLEN:
18507 case CHARSETID:
18508 case CHARSETFORM:
18509 case ACCEPT:
18510 case ACCESSIBLE:
18511 case COPY:
18512 case DEFINE:
18513 case DISCONNECT:
18514 case HOST:
18515 case PRINT:
18516 case QUIT:
18517 case REMARK:
18518 case UNDEFINE:
18519 case VARIABLE:
18520 case WHENEVER:
18521 case ATTACH:
18522 case CAST:
18523 case TREAT:
18524 case TRIM:
18525 case LEFT:
18526 case RIGHT:
18527 case BOTH:
18528 case EMPTY:
18529 case MULTISET:
18530 case SUBMULTISET:
18531 case LEADING:
18532 case TRAILING:
18533 case CHAR_CS:
18534 case NCHAR_CS:
18535 case DBTIMEZONE:
18536 case SESSIONTIMEZONE:
18537 case AUTHENTICATED:
18538 case LINK:
18539 case SHARED:
18540 case DIRECTORY:
18541 case USER:
18542 case IDENTIFIER:
18543 case UNSIGNED_NUMERIC_LITERAL:
18544 case CHARACTER_LITERAL:
18545 case STRING_LITERAL:
18546 case QUOTED_LITERAL:
18547 simpleNode = UnaryExpressionNotPlusMinus();
18548 sb.append(simpleNode.getImage());
18549 break;
18550 default:
18551 jj_la1[252] = jj_gen;
18552 jj_consume_token(-1);
18553 throw new ParseException();
18554 }
18555 jjtree.closeNodeScope(jjtn000, true);
18556 jjtc000 = false;
18557 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18558 } catch (Throwable jjte000) {
18559 if (jjtc000) {
18560 jjtree.clearNodeScope(jjtn000);
18561 jjtc000 = false;
18562 } else {
18563 jjtree.popNode();
18564 }
18565 if (jjte000 instanceof RuntimeException) {
18566 {if (true) throw (RuntimeException)jjte000;}
18567 }
18568 if (jjte000 instanceof ParseException) {
18569 {if (true) throw (ParseException)jjte000;}
18570 }
18571 {if (true) throw (Error)jjte000;}
18572 } finally {
18573 if (jjtc000) {
18574 jjtree.closeNodeScope(jjtn000, true);
18575 }
18576 }
18577 throw new Error("Missing return statement in function");
18578 }
18579
18580 final public ASTUnaryExpressionNotPlusMinus UnaryExpressionNotPlusMinus() throws ParseException {
18581
18582 ASTUnaryExpressionNotPlusMinus jjtn000 = new ASTUnaryExpressionNotPlusMinus(this, JJTUNARYEXPRESSIONNOTPLUSMINUS);
18583 boolean jjtc000 = true;
18584 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18585 try {
18586 switch (jj_nt.kind) {
18587 case NOT:
18588 jj_consume_token(NOT);
18589 sb.append(" NOT ");
18590 simpleNode = UnaryExpression(false);
18591 sb.append(simpleNode.getImage());
18592 break;
18593 case 5:
18594 case REPLACE:
18595 case DEFINER:
18596 case CURRENT_USER:
18597 case LANGUAGE:
18598 case INLINE:
18599 case ADD:
18600 case AGGREGATE:
18601 case ARRAY:
18602 case AT:
18603 case ATTRIBUTE:
18604 case AUTHID:
18605 case BODY:
18606 case BULK:
18607 case BYTE:
18608 case CASCADE:
18609 case CASE:
18610 case CLOSE:
18611 case COALESCE:
18612 case COLLECT:
18613 case COLUMN:
18614 case COMMENT:
18615 case COMMIT:
18616 case CONSTRUCTOR:
18617 case CONTINUE:
18618 case CONVERT:
18619 case CURRENT:
18620 case CURSOR:
18621 case DATA:
18622 case DATE:
18623 case DAY:
18624 case DISABLE:
18625 case EDITIONABLE:
18626 case ELEMENT:
18627 case ENABLE:
18628 case ESCAPE:
18629 case EXCEPT:
18630 case EXCEPTIONS:
18631 case EXIT:
18632 case EXTERNAL:
18633 case EXTENDS:
18634 case EXTRACT:
18635 case FALSE:
18636 case FINAL:
18637 case FORCE:
18638 case FUNCTION:
18639 case GLOBAL:
18640 case HASH:
18641 case HEAP:
18642 case HOUR:
18643 case IMMEDIATE:
18644 case INDICES:
18645 case INDEXTYPE:
18646 case INDICATOR:
18647 case INSTANTIABLE:
18648 case INTERVAL:
18649 case INVALIDATE:
18650 case ISOLATION:
18651 case JAVA:
18652 case LEVEL:
18653 case LIMIT:
18654 case LOOP:
18655 case MAP:
18656 case MAX:
18657 case MEMBER:
18658 case MERGE:
18659 case MIN:
18660 case MINUTE:
18661 case MLSLABEL:
18662 case MODIFY:
18663 case MOD:
18664 case MONTH:
18665 case NATURAL:
18666 case NEW:
18667 case NEW_DOT:
18668 case NO:
18669 case NONEDITIONABLE:
18670 case NULL:
18671 case NULLIF:
18672 case OBJECT:
18673 case OID:
18674 case OPAQUE:
18675 case OPEN:
18676 case OPERATOR:
18677 case ORGANIZATION:
18678 case OTHERS:
18679 case OVERRIDING:
18680 case PACKAGE:
18681 case PARTITION:
18682 case PRESERVE:
18683 case PRIVATE:
18684 case PROCEDURE:
18685 case RANGE:
18686 case RAW:
18687 case REAL:
18688 case RECORD:
18689 case REF:
18690 case RELEASE:
18691 case RELIES_ON:
18692 case RENAME:
18693 case RESULT:
18694 case RETURN:
18695 case RETURNING:
18696 case REVERSE:
18697 case ROLLBACK:
18698 case ROW:
18699 case ROWS:
18700 case ROWID:
18701 case ROWNUM:
18702 case SAVE:
18703 case SAVEPOINT:
18704 case SECOND:
18705 case SELECT:
18706 case SELF:
18707 case SET:
18708 case SPACE:
18709 case SQL:
18710 case SQLCODE:
18711 case SQLERRM:
18712 case STATIC:
18713 case SUBTYPE:
18714 case SUBSTITUTABLE:
18715 case SUCCESSFUL:
18716 case SYSDATE:
18717 case SYS_REFCURSOR:
18718 case TEMPORARY:
18719 case TIME:
18720 case TIMESTAMP:
18721 case TIMEZONE_REGION:
18722 case TIMEZONE_ABBR:
18723 case TIMEZONE_MINUTE:
18724 case TIMEZONE_HOUR:
18725 case TRANSACTION:
18726 case TRUE:
18727 case TYPE:
18728 case UNDER:
18729 case USING:
18730 case YES:
18731 case SHOW:
18732 case A:
18733 case DOUBLE:
18734 case DEC:
18735 case PRECISION:
18736 case INT:
18737 case NUMERIC:
18738 case NCHAR:
18739 case NVARCHAR2:
18740 case STRING:
18741 case UROWID:
18742 case VARRAY:
18743 case VARYING:
18744 case BFILE:
18745 case BLOB:
18746 case CLOB:
18747 case NCLOB:
18748 case YEAR:
18749 case LOCAL:
18750 case WITH:
18751 case ZONE:
18752 case CHARACTER:
18753 case AFTER:
18754 case BEFORE:
18755 case OLD:
18756 case PARENT:
18757 case ANALYZE:
18758 case ASSOCIATE:
18759 case AUDIT:
18760 case COMPOUND:
18761 case DATABASE:
18762 case CALL:
18763 case DDL:
18764 case DISASSOCIATE:
18765 case EACH:
18766 case FOLLOWS:
18767 case LOGOFF:
18768 case LOGON:
18769 case NESTED:
18770 case NOAUDIT:
18771 case SCHEMA:
18772 case SERVERERROR:
18773 case SHUTDOWN:
18774 case STARTUP:
18775 case STATEMENT:
18776 case STATISTICS:
18777 case SUSPEND:
18778 case TRUNCATE:
18779 case WRAPPED:
18780 case LIBRARY:
18781 case NAME:
18782 case STRUCT:
18783 case CONTEXT:
18784 case PARAMETERS:
18785 case LENGTH:
18786 case TDO:
18787 case MAXLEN:
18788 case CHARSETID:
18789 case CHARSETFORM:
18790 case ACCEPT:
18791 case ACCESSIBLE:
18792 case COPY:
18793 case DEFINE:
18794 case DISCONNECT:
18795 case HOST:
18796 case PRINT:
18797 case QUIT:
18798 case REMARK:
18799 case UNDEFINE:
18800 case VARIABLE:
18801 case WHENEVER:
18802 case ATTACH:
18803 case CAST:
18804 case TREAT:
18805 case TRIM:
18806 case LEFT:
18807 case RIGHT:
18808 case BOTH:
18809 case EMPTY:
18810 case MULTISET:
18811 case SUBMULTISET:
18812 case LEADING:
18813 case TRAILING:
18814 case CHAR_CS:
18815 case NCHAR_CS:
18816 case DBTIMEZONE:
18817 case SESSIONTIMEZONE:
18818 case AUTHENTICATED:
18819 case LINK:
18820 case SHARED:
18821 case DIRECTORY:
18822 case USER:
18823 case IDENTIFIER:
18824 case UNSIGNED_NUMERIC_LITERAL:
18825 case CHARACTER_LITERAL:
18826 case STRING_LITERAL:
18827 case QUOTED_LITERAL:
18828 simpleNode = IsOfTypeCondition();
18829 sb.append(simpleNode.getImage());
18830 break;
18831 default:
18832 jj_la1[253] = jj_gen;
18833 jj_consume_token(-1);
18834 throw new ParseException();
18835 }
18836 jjtree.closeNodeScope(jjtn000, true);
18837 jjtc000 = false;
18838 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18839 } catch (Throwable jjte000) {
18840 if (jjtc000) {
18841 jjtree.clearNodeScope(jjtn000);
18842 jjtc000 = false;
18843 } else {
18844 jjtree.popNode();
18845 }
18846 if (jjte000 instanceof RuntimeException) {
18847 {if (true) throw (RuntimeException)jjte000;}
18848 }
18849 if (jjte000 instanceof ParseException) {
18850 {if (true) throw (ParseException)jjte000;}
18851 }
18852 {if (true) throw (Error)jjte000;}
18853 } finally {
18854 if (jjtc000) {
18855 jjtree.closeNodeScope(jjtn000, true);
18856 }
18857 }
18858 throw new Error("Missing return statement in function");
18859 }
18860
18861 final public ASTIsOfTypeCondition IsOfTypeCondition() throws ParseException {
18862
18863 ASTIsOfTypeCondition jjtn000 = new ASTIsOfTypeCondition(this, JJTISOFTYPECONDITION);
18864 boolean jjtc000 = true;
18865 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; PLSQLNode name = null; StringBuilder sb = new StringBuilder();
18866 try {
18867 if (jj_2_46(2147483647)) {
18868 name = Name();
18869 sb.append(name.getImage());
18870 jj_consume_token(IS);
18871 sb.append(" IS");
18872 switch (jj_nt.kind) {
18873 case NOT:
18874 jj_consume_token(NOT);
18875 sb.append(" NOT");
18876 break;
18877 default:
18878 jj_la1[254] = jj_gen;
18879 ;
18880 }
18881 jj_consume_token(OF);
18882 sb.append(" OF");
18883 switch (jj_nt.kind) {
18884 case TYPE:
18885 jj_consume_token(TYPE);
18886 break;
18887 default:
18888 jj_la1[255] = jj_gen;
18889 ;
18890 }
18891 jj_consume_token(5);
18892 switch (jj_nt.kind) {
18893 case ONLY:
18894 jj_consume_token(ONLY);
18895 break;
18896 default:
18897 jj_la1[256] = jj_gen;
18898 ;
18899 }
18900 Name();
18901 label_61:
18902 while (true) {
18903 switch (jj_nt.kind) {
18904 case 6:
18905 ;
18906 break;
18907 default:
18908 jj_la1[257] = jj_gen;
18909 break label_61;
18910 }
18911 jj_consume_token(6);
18912 switch (jj_nt.kind) {
18913 case ONLY:
18914 jj_consume_token(ONLY);
18915 break;
18916 default:
18917 jj_la1[258] = jj_gen;
18918 ;
18919 }
18920 Name();
18921 }
18922 jj_consume_token(7);
18923 } else {
18924 switch (jj_nt.kind) {
18925 case 5:
18926 case REPLACE:
18927 case DEFINER:
18928 case CURRENT_USER:
18929 case LANGUAGE:
18930 case INLINE:
18931 case ADD:
18932 case AGGREGATE:
18933 case ARRAY:
18934 case AT:
18935 case ATTRIBUTE:
18936 case AUTHID:
18937 case BODY:
18938 case BULK:
18939 case BYTE:
18940 case CASCADE:
18941 case CASE:
18942 case CLOSE:
18943 case COALESCE:
18944 case COLLECT:
18945 case COLUMN:
18946 case COMMENT:
18947 case COMMIT:
18948 case CONSTRUCTOR:
18949 case CONTINUE:
18950 case CONVERT:
18951 case CURRENT:
18952 case CURSOR:
18953 case DATA:
18954 case DATE:
18955 case DAY:
18956 case DISABLE:
18957 case EDITIONABLE:
18958 case ELEMENT:
18959 case ENABLE:
18960 case ESCAPE:
18961 case EXCEPT:
18962 case EXCEPTIONS:
18963 case EXIT:
18964 case EXTERNAL:
18965 case EXTENDS:
18966 case EXTRACT:
18967 case FALSE:
18968 case FINAL:
18969 case FORCE:
18970 case FUNCTION:
18971 case GLOBAL:
18972 case HASH:
18973 case HEAP:
18974 case HOUR:
18975 case IMMEDIATE:
18976 case INDICES:
18977 case INDEXTYPE:
18978 case INDICATOR:
18979 case INSTANTIABLE:
18980 case INTERVAL:
18981 case INVALIDATE:
18982 case ISOLATION:
18983 case JAVA:
18984 case LEVEL:
18985 case LIMIT:
18986 case LOOP:
18987 case MAP:
18988 case MAX:
18989 case MEMBER:
18990 case MERGE:
18991 case MIN:
18992 case MINUTE:
18993 case MLSLABEL:
18994 case MODIFY:
18995 case MOD:
18996 case MONTH:
18997 case NATURAL:
18998 case NEW:
18999 case NEW_DOT:
19000 case NO:
19001 case NONEDITIONABLE:
19002 case NULL:
19003 case NULLIF:
19004 case OBJECT:
19005 case OID:
19006 case OPAQUE:
19007 case OPEN:
19008 case OPERATOR:
19009 case ORGANIZATION:
19010 case OTHERS:
19011 case OVERRIDING:
19012 case PACKAGE:
19013 case PARTITION:
19014 case PRESERVE:
19015 case PRIVATE:
19016 case PROCEDURE:
19017 case RANGE:
19018 case RAW:
19019 case REAL:
19020 case RECORD:
19021 case REF:
19022 case RELEASE:
19023 case RELIES_ON:
19024 case RENAME:
19025 case RESULT:
19026 case RETURN:
19027 case RETURNING:
19028 case REVERSE:
19029 case ROLLBACK:
19030 case ROW:
19031 case ROWS:
19032 case ROWID:
19033 case ROWNUM:
19034 case SAVE:
19035 case SAVEPOINT:
19036 case SECOND:
19037 case SELECT:
19038 case SELF:
19039 case SET:
19040 case SPACE:
19041 case SQL:
19042 case SQLCODE:
19043 case SQLERRM:
19044 case STATIC:
19045 case SUBTYPE:
19046 case SUBSTITUTABLE:
19047 case SUCCESSFUL:
19048 case SYSDATE:
19049 case SYS_REFCURSOR:
19050 case TEMPORARY:
19051 case TIME:
19052 case TIMESTAMP:
19053 case TIMEZONE_REGION:
19054 case TIMEZONE_ABBR:
19055 case TIMEZONE_MINUTE:
19056 case TIMEZONE_HOUR:
19057 case TRANSACTION:
19058 case TRUE:
19059 case TYPE:
19060 case UNDER:
19061 case USING:
19062 case YES:
19063 case SHOW:
19064 case A:
19065 case DOUBLE:
19066 case DEC:
19067 case PRECISION:
19068 case INT:
19069 case NUMERIC:
19070 case NCHAR:
19071 case NVARCHAR2:
19072 case STRING:
19073 case UROWID:
19074 case VARRAY:
19075 case VARYING:
19076 case BFILE:
19077 case BLOB:
19078 case CLOB:
19079 case NCLOB:
19080 case YEAR:
19081 case LOCAL:
19082 case WITH:
19083 case ZONE:
19084 case CHARACTER:
19085 case AFTER:
19086 case BEFORE:
19087 case OLD:
19088 case PARENT:
19089 case ANALYZE:
19090 case ASSOCIATE:
19091 case AUDIT:
19092 case COMPOUND:
19093 case DATABASE:
19094 case CALL:
19095 case DDL:
19096 case DISASSOCIATE:
19097 case EACH:
19098 case FOLLOWS:
19099 case LOGOFF:
19100 case LOGON:
19101 case NESTED:
19102 case NOAUDIT:
19103 case SCHEMA:
19104 case SERVERERROR:
19105 case SHUTDOWN:
19106 case STARTUP:
19107 case STATEMENT:
19108 case STATISTICS:
19109 case SUSPEND:
19110 case TRUNCATE:
19111 case WRAPPED:
19112 case LIBRARY:
19113 case NAME:
19114 case STRUCT:
19115 case CONTEXT:
19116 case PARAMETERS:
19117 case LENGTH:
19118 case TDO:
19119 case MAXLEN:
19120 case CHARSETID:
19121 case CHARSETFORM:
19122 case ACCEPT:
19123 case ACCESSIBLE:
19124 case COPY:
19125 case DEFINE:
19126 case DISCONNECT:
19127 case HOST:
19128 case PRINT:
19129 case QUIT:
19130 case REMARK:
19131 case UNDEFINE:
19132 case VARIABLE:
19133 case WHENEVER:
19134 case ATTACH:
19135 case CAST:
19136 case TREAT:
19137 case TRIM:
19138 case LEFT:
19139 case RIGHT:
19140 case BOTH:
19141 case EMPTY:
19142 case MULTISET:
19143 case SUBMULTISET:
19144 case LEADING:
19145 case TRAILING:
19146 case CHAR_CS:
19147 case NCHAR_CS:
19148 case DBTIMEZONE:
19149 case SESSIONTIMEZONE:
19150 case AUTHENTICATED:
19151 case LINK:
19152 case SHARED:
19153 case DIRECTORY:
19154 case USER:
19155 case IDENTIFIER:
19156 case UNSIGNED_NUMERIC_LITERAL:
19157 case CHARACTER_LITERAL:
19158 case STRING_LITERAL:
19159 case QUOTED_LITERAL:
19160 simpleNode = PrimaryExpression();
19161 sb.append(simpleNode.getImage());
19162 break;
19163 default:
19164 jj_la1[259] = jj_gen;
19165 jj_consume_token(-1);
19166 throw new ParseException();
19167 }
19168 }
19169 jjtree.closeNodeScope(jjtn000, true);
19170 jjtc000 = false;
19171 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
19172 } catch (Throwable jjte000) {
19173 if (jjtc000) {
19174 jjtree.clearNodeScope(jjtn000);
19175 jjtc000 = false;
19176 } else {
19177 jjtree.popNode();
19178 }
19179 if (jjte000 instanceof RuntimeException) {
19180 {if (true) throw (RuntimeException)jjte000;}
19181 }
19182 if (jjte000 instanceof ParseException) {
19183 {if (true) throw (ParseException)jjte000;}
19184 }
19185 {if (true) throw (Error)jjte000;}
19186 } finally {
19187 if (jjtc000) {
19188 jjtree.closeNodeScope(jjtn000, true);
19189 }
19190 }
19191 throw new Error("Missing return statement in function");
19192 }
19193
19194
19195
19196
19197
19198
19199 final public ASTPrimaryExpression PrimaryExpression() throws ParseException {
19200
19201 ASTPrimaryExpression jjtn000 = new ASTPrimaryExpression(this, JJTPRIMARYEXPRESSION);
19202 boolean jjtc000 = true;
19203 jjtree.openNodeScope(jjtn000);Token thisToken ; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
19204 try {
19205 switch (jj_nt.kind) {
19206 case NEW_DOT:
19207 jj_consume_token(NEW_DOT);
19208 simpleNode = QualifiedID();
19209 sb.append(" NEW."); sb.append(simpleNode.getImage());
19210 break;
19211 case 5:
19212 case REPLACE:
19213 case DEFINER:
19214 case CURRENT_USER:
19215 case LANGUAGE:
19216 case INLINE:
19217 case ADD:
19218 case AGGREGATE:
19219 case ARRAY:
19220 case AT:
19221 case ATTRIBUTE:
19222 case AUTHID:
19223 case BODY:
19224 case BULK:
19225 case BYTE:
19226 case CASCADE:
19227 case CASE:
19228 case CLOSE:
19229 case COALESCE:
19230 case COLLECT:
19231 case COLUMN:
19232 case COMMENT:
19233 case COMMIT:
19234 case CONSTRUCTOR:
19235 case CONTINUE:
19236 case CONVERT:
19237 case CURRENT:
19238 case CURSOR:
19239 case DATA:
19240 case DATE:
19241 case DAY:
19242 case DISABLE:
19243 case EDITIONABLE:
19244 case ELEMENT:
19245 case ENABLE:
19246 case ESCAPE:
19247 case EXCEPT:
19248 case EXCEPTIONS:
19249 case EXIT:
19250 case EXTERNAL:
19251 case EXTENDS:
19252 case EXTRACT:
19253 case FALSE:
19254 case FINAL:
19255 case FORCE:
19256 case FUNCTION:
19257 case GLOBAL:
19258 case HASH:
19259 case HEAP:
19260 case HOUR:
19261 case IMMEDIATE:
19262 case INDICES:
19263 case INDEXTYPE:
19264 case INDICATOR:
19265 case INSTANTIABLE:
19266 case INTERVAL:
19267 case INVALIDATE:
19268 case ISOLATION:
19269 case JAVA:
19270 case LEVEL:
19271 case LIMIT:
19272 case LOOP:
19273 case MAP:
19274 case MAX:
19275 case MEMBER:
19276 case MERGE:
19277 case MIN:
19278 case MINUTE:
19279 case MLSLABEL:
19280 case MODIFY:
19281 case MOD:
19282 case MONTH:
19283 case NATURAL:
19284 case NEW:
19285 case NO:
19286 case NONEDITIONABLE:
19287 case NULL:
19288 case NULLIF:
19289 case OBJECT:
19290 case OID:
19291 case OPAQUE:
19292 case OPEN:
19293 case OPERATOR:
19294 case ORGANIZATION:
19295 case OTHERS:
19296 case OVERRIDING:
19297 case PACKAGE:
19298 case PARTITION:
19299 case PRESERVE:
19300 case PRIVATE:
19301 case PROCEDURE:
19302 case RANGE:
19303 case RAW:
19304 case REAL:
19305 case RECORD:
19306 case REF:
19307 case RELEASE:
19308 case RELIES_ON:
19309 case RENAME:
19310 case RESULT:
19311 case RETURN:
19312 case RETURNING:
19313 case REVERSE:
19314 case ROLLBACK:
19315 case ROW:
19316 case ROWS:
19317 case ROWID:
19318 case ROWNUM:
19319 case SAVE:
19320 case SAVEPOINT:
19321 case SECOND:
19322 case SELECT:
19323 case SELF:
19324 case SET:
19325 case SPACE:
19326 case SQL:
19327 case SQLCODE:
19328 case SQLERRM:
19329 case STATIC:
19330 case SUBTYPE:
19331 case SUBSTITUTABLE:
19332 case SUCCESSFUL:
19333 case SYSDATE:
19334 case SYS_REFCURSOR:
19335 case TEMPORARY:
19336 case TIME:
19337 case TIMESTAMP:
19338 case TIMEZONE_REGION:
19339 case TIMEZONE_ABBR:
19340 case TIMEZONE_MINUTE:
19341 case TIMEZONE_HOUR:
19342 case TRANSACTION:
19343 case TRUE:
19344 case TYPE:
19345 case UNDER:
19346 case USING:
19347 case YES:
19348 case SHOW:
19349 case A:
19350 case DOUBLE:
19351 case DEC:
19352 case PRECISION:
19353 case INT:
19354 case NUMERIC:
19355 case NCHAR:
19356 case NVARCHAR2:
19357 case STRING:
19358 case UROWID:
19359 case VARRAY:
19360 case VARYING:
19361 case BFILE:
19362 case BLOB:
19363 case CLOB:
19364 case NCLOB:
19365 case YEAR:
19366 case LOCAL:
19367 case WITH:
19368 case ZONE:
19369 case CHARACTER:
19370 case AFTER:
19371 case BEFORE:
19372 case OLD:
19373 case PARENT:
19374 case ANALYZE:
19375 case ASSOCIATE:
19376 case AUDIT:
19377 case COMPOUND:
19378 case DATABASE:
19379 case CALL:
19380 case DDL:
19381 case DISASSOCIATE:
19382 case EACH:
19383 case FOLLOWS:
19384 case LOGOFF:
19385 case LOGON:
19386 case NESTED:
19387 case NOAUDIT:
19388 case SCHEMA:
19389 case SERVERERROR:
19390 case SHUTDOWN:
19391 case STARTUP:
19392 case STATEMENT:
19393 case STATISTICS:
19394 case SUSPEND:
19395 case TRUNCATE:
19396 case WRAPPED:
19397 case LIBRARY:
19398 case NAME:
19399 case STRUCT:
19400 case CONTEXT:
19401 case PARAMETERS:
19402 case LENGTH:
19403 case TDO:
19404 case MAXLEN:
19405 case CHARSETID:
19406 case CHARSETFORM:
19407 case ACCEPT:
19408 case ACCESSIBLE:
19409 case COPY:
19410 case DEFINE:
19411 case DISCONNECT:
19412 case HOST:
19413 case PRINT:
19414 case QUIT:
19415 case REMARK:
19416 case UNDEFINE:
19417 case VARIABLE:
19418 case WHENEVER:
19419 case ATTACH:
19420 case CAST:
19421 case TREAT:
19422 case TRIM:
19423 case LEFT:
19424 case RIGHT:
19425 case BOTH:
19426 case EMPTY:
19427 case MULTISET:
19428 case SUBMULTISET:
19429 case LEADING:
19430 case TRAILING:
19431 case CHAR_CS:
19432 case NCHAR_CS:
19433 case DBTIMEZONE:
19434 case SESSIONTIMEZONE:
19435 case AUTHENTICATED:
19436 case LINK:
19437 case SHARED:
19438 case DIRECTORY:
19439 case USER:
19440 case IDENTIFIER:
19441 case UNSIGNED_NUMERIC_LITERAL:
19442 case CHARACTER_LITERAL:
19443 case STRING_LITERAL:
19444 case QUOTED_LITERAL:
19445 if (jj_2_47(2147483647)) {
19446 jj_consume_token(NEW);
19447 sb.append(" NEW ");
19448 simpleNode = PrimaryPrefix();
19449 sb.append(simpleNode.getImage());
19450 } else {
19451 switch (jj_nt.kind) {
19452 case 5:
19453 case REPLACE:
19454 case DEFINER:
19455 case CURRENT_USER:
19456 case LANGUAGE:
19457 case INLINE:
19458 case ADD:
19459 case AGGREGATE:
19460 case ARRAY:
19461 case AT:
19462 case ATTRIBUTE:
19463 case AUTHID:
19464 case BODY:
19465 case BULK:
19466 case BYTE:
19467 case CASCADE:
19468 case CASE:
19469 case CLOSE:
19470 case COALESCE:
19471 case COLLECT:
19472 case COLUMN:
19473 case COMMENT:
19474 case COMMIT:
19475 case CONSTRUCTOR:
19476 case CONTINUE:
19477 case CONVERT:
19478 case CURRENT:
19479 case CURSOR:
19480 case DATA:
19481 case DATE:
19482 case DAY:
19483 case DISABLE:
19484 case EDITIONABLE:
19485 case ELEMENT:
19486 case ENABLE:
19487 case ESCAPE:
19488 case EXCEPT:
19489 case EXCEPTIONS:
19490 case EXIT:
19491 case EXTERNAL:
19492 case EXTENDS:
19493 case EXTRACT:
19494 case FALSE:
19495 case FINAL:
19496 case FORCE:
19497 case FUNCTION:
19498 case GLOBAL:
19499 case HASH:
19500 case HEAP:
19501 case HOUR:
19502 case IMMEDIATE:
19503 case INDICES:
19504 case INDEXTYPE:
19505 case INDICATOR:
19506 case INSTANTIABLE:
19507 case INTERVAL:
19508 case INVALIDATE:
19509 case ISOLATION:
19510 case JAVA:
19511 case LEVEL:
19512 case LIMIT:
19513 case LOOP:
19514 case MAP:
19515 case MAX:
19516 case MEMBER:
19517 case MERGE:
19518 case MIN:
19519 case MINUTE:
19520 case MLSLABEL:
19521 case MODIFY:
19522 case MOD:
19523 case MONTH:
19524 case NATURAL:
19525 case NEW:
19526 case NO:
19527 case NONEDITIONABLE:
19528 case NULL:
19529 case NULLIF:
19530 case OBJECT:
19531 case OID:
19532 case OPAQUE:
19533 case OPEN:
19534 case OPERATOR:
19535 case ORGANIZATION:
19536 case OTHERS:
19537 case OVERRIDING:
19538 case PACKAGE:
19539 case PARTITION:
19540 case PRESERVE:
19541 case PRIVATE:
19542 case PROCEDURE:
19543 case RANGE:
19544 case RAW:
19545 case REAL:
19546 case RECORD:
19547 case REF:
19548 case RELEASE:
19549 case RELIES_ON:
19550 case RENAME:
19551 case RESULT:
19552 case RETURN:
19553 case RETURNING:
19554 case REVERSE:
19555 case ROLLBACK:
19556 case ROW:
19557 case ROWS:
19558 case ROWID:
19559 case ROWNUM:
19560 case SAVE:
19561 case SAVEPOINT:
19562 case SECOND:
19563 case SELECT:
19564 case SELF:
19565 case SET:
19566 case SPACE:
19567 case SQL:
19568 case SQLCODE:
19569 case SQLERRM:
19570 case STATIC:
19571 case SUBTYPE:
19572 case SUBSTITUTABLE:
19573 case SUCCESSFUL:
19574 case SYSDATE:
19575 case SYS_REFCURSOR:
19576 case TEMPORARY:
19577 case TIME:
19578 case TIMESTAMP:
19579 case TIMEZONE_REGION:
19580 case TIMEZONE_ABBR:
19581 case TIMEZONE_MINUTE:
19582 case TIMEZONE_HOUR:
19583 case TRANSACTION:
19584 case TRUE:
19585 case TYPE:
19586 case UNDER:
19587 case USING:
19588 case YES:
19589 case SHOW:
19590 case A:
19591 case DOUBLE:
19592 case DEC:
19593 case PRECISION:
19594 case INT:
19595 case NUMERIC:
19596 case NCHAR:
19597 case NVARCHAR2:
19598 case STRING:
19599 case UROWID:
19600 case VARRAY:
19601 case VARYING:
19602 case BFILE:
19603 case BLOB:
19604 case CLOB:
19605 case NCLOB:
19606 case YEAR:
19607 case LOCAL:
19608 case WITH:
19609 case ZONE:
19610 case CHARACTER:
19611 case AFTER:
19612 case BEFORE:
19613 case OLD:
19614 case PARENT:
19615 case ANALYZE:
19616 case ASSOCIATE:
19617 case AUDIT:
19618 case COMPOUND:
19619 case DATABASE:
19620 case CALL:
19621 case DDL:
19622 case DISASSOCIATE:
19623 case EACH:
19624 case FOLLOWS:
19625 case LOGOFF:
19626 case LOGON:
19627 case NESTED:
19628 case NOAUDIT:
19629 case SCHEMA:
19630 case SERVERERROR:
19631 case SHUTDOWN:
19632 case STARTUP:
19633 case STATEMENT:
19634 case STATISTICS:
19635 case SUSPEND:
19636 case TRUNCATE:
19637 case WRAPPED:
19638 case LIBRARY:
19639 case NAME:
19640 case STRUCT:
19641 case CONTEXT:
19642 case PARAMETERS:
19643 case LENGTH:
19644 case TDO:
19645 case MAXLEN:
19646 case CHARSETID:
19647 case CHARSETFORM:
19648 case ACCEPT:
19649 case ACCESSIBLE:
19650 case COPY:
19651 case DEFINE:
19652 case DISCONNECT:
19653 case HOST:
19654 case PRINT:
19655 case QUIT:
19656 case REMARK:
19657 case UNDEFINE:
19658 case VARIABLE:
19659 case WHENEVER:
19660 case ATTACH:
19661 case CAST:
19662 case TREAT:
19663 case TRIM:
19664 case LEFT:
19665 case RIGHT:
19666 case BOTH:
19667 case EMPTY:
19668 case MULTISET:
19669 case SUBMULTISET:
19670 case LEADING:
19671 case TRAILING:
19672 case CHAR_CS:
19673 case NCHAR_CS:
19674 case DBTIMEZONE:
19675 case SESSIONTIMEZONE:
19676 case AUTHENTICATED:
19677 case LINK:
19678 case SHARED:
19679 case DIRECTORY:
19680 case USER:
19681 case IDENTIFIER:
19682 case UNSIGNED_NUMERIC_LITERAL:
19683 case CHARACTER_LITERAL:
19684 case STRING_LITERAL:
19685 case QUOTED_LITERAL:
19686 simpleNode = PrimaryPrefix();
19687 sb.append(simpleNode.getImage());
19688 break;
19689 default:
19690 jj_la1[260] = jj_gen;
19691 jj_consume_token(-1);
19692 throw new ParseException();
19693 }
19694 }
19695 label_62:
19696 while (true) {
19697 if (jj_2_48(2)) {
19698 ;
19699 } else {
19700 break label_62;
19701 }
19702 simpleNode = PrimarySuffix();
19703 sb.append(simpleNode.getImage());
19704 }
19705 break;
19706 default:
19707 jj_la1[261] = jj_gen;
19708 jj_consume_token(-1);
19709 throw new ParseException();
19710 }
19711 jjtree.closeNodeScope(jjtn000, true);
19712 jjtc000 = false;
19713 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
19714 } catch (Throwable jjte000) {
19715 if (jjtc000) {
19716 jjtree.clearNodeScope(jjtn000);
19717 jjtc000 = false;
19718 } else {
19719 jjtree.popNode();
19720 }
19721 if (jjte000 instanceof RuntimeException) {
19722 {if (true) throw (RuntimeException)jjte000;}
19723 }
19724 if (jjte000 instanceof ParseException) {
19725 {if (true) throw (ParseException)jjte000;}
19726 }
19727 {if (true) throw (Error)jjte000;}
19728 } finally {
19729 if (jjtc000) {
19730 jjtree.closeNodeScope(jjtn000, true);
19731 }
19732 }
19733 throw new Error("Missing return statement in function");
19734 }
19735
19736 final public ASTPrimaryPrefix PrimaryPrefix() throws ParseException {
19737
19738 ASTPrimaryPrefix jjtn000 = new ASTPrimaryPrefix(this, JJTPRIMARYPREFIX);
19739 boolean jjtc000 = true;
19740 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
19741 try {
19742 switch (jj_nt.kind) {
19743 case DATE:
19744 case FALSE:
19745 case INTERVAL:
19746 case NULL:
19747 case TIMESTAMP:
19748 case TRUE:
19749 case UNSIGNED_NUMERIC_LITERAL:
19750 case CHARACTER_LITERAL:
19751 case STRING_LITERAL:
19752 simpleNode = Literal();
19753 sb.append(simpleNode.getImage()) ;
19754 break;
19755 default:
19756 jj_la1[263] = jj_gen;
19757 if (jj_2_49(2147483647)) {
19758 simpleNode = MultiSetCondition();
19759 } else if (jj_2_50(2147483647)) {
19760 simpleNode = TrimExpression();
19761 } else if (jj_2_51(2147483647)) {
19762 simpleNode = CaseExpression();
19763 sb.append(simpleNode.getImage()) ;
19764 } else if (jj_2_52(2147483647)) {
19765 simpleNode = ObjectExpression();
19766 sb.append(simpleNode.getImage()) ;
19767 } else {
19768 switch (jj_nt.kind) {
19769 case REPLACE:
19770 case DEFINER:
19771 case CURRENT_USER:
19772 case LANGUAGE:
19773 case INLINE:
19774 case ADD:
19775 case AGGREGATE:
19776 case ARRAY:
19777 case AT:
19778 case ATTRIBUTE:
19779 case AUTHID:
19780 case BODY:
19781 case BULK:
19782 case BYTE:
19783 case CASCADE:
19784 case CLOSE:
19785 case COALESCE:
19786 case COLLECT:
19787 case COLUMN:
19788 case COMMENT:
19789 case COMMIT:
19790 case CONSTRUCTOR:
19791 case CONTINUE:
19792 case CONVERT:
19793 case CURRENT:
19794 case CURSOR:
19795 case DATA:
19796 case DAY:
19797 case DISABLE:
19798 case EDITIONABLE:
19799 case ELEMENT:
19800 case ENABLE:
19801 case ESCAPE:
19802 case EXCEPT:
19803 case EXCEPTIONS:
19804 case EXIT:
19805 case EXTERNAL:
19806 case EXTENDS:
19807 case EXTRACT:
19808 case FALSE:
19809 case FINAL:
19810 case FORCE:
19811 case FUNCTION:
19812 case GLOBAL:
19813 case HASH:
19814 case HEAP:
19815 case HOUR:
19816 case IMMEDIATE:
19817 case INDICES:
19818 case INDEXTYPE:
19819 case INDICATOR:
19820 case INSTANTIABLE:
19821 case INTERVAL:
19822 case INVALIDATE:
19823 case ISOLATION:
19824 case JAVA:
19825 case LEVEL:
19826 case LIMIT:
19827 case LOOP:
19828 case MAP:
19829 case MAX:
19830 case MEMBER:
19831 case MERGE:
19832 case MIN:
19833 case MINUTE:
19834 case MLSLABEL:
19835 case MODIFY:
19836 case MOD:
19837 case MONTH:
19838 case NATURAL:
19839 case NEW:
19840 case NO:
19841 case NONEDITIONABLE:
19842 case NULLIF:
19843 case OBJECT:
19844 case OID:
19845 case OPAQUE:
19846 case OPEN:
19847 case OPERATOR:
19848 case ORGANIZATION:
19849 case OTHERS:
19850 case OVERRIDING:
19851 case PACKAGE:
19852 case PARTITION:
19853 case PRESERVE:
19854 case PRIVATE:
19855 case PROCEDURE:
19856 case RANGE:
19857 case RAW:
19858 case REAL:
19859 case RECORD:
19860 case REF:
19861 case RELEASE:
19862 case RELIES_ON:
19863 case RENAME:
19864 case RESULT:
19865 case RETURN:
19866 case RETURNING:
19867 case REVERSE:
19868 case ROLLBACK:
19869 case ROW:
19870 case ROWS:
19871 case ROWID:
19872 case ROWNUM:
19873 case SAVE:
19874 case SAVEPOINT:
19875 case SECOND:
19876 case SELF:
19877 case SET:
19878 case SPACE:
19879 case SQL:
19880 case SQLCODE:
19881 case SQLERRM:
19882 case STATIC:
19883 case SUBTYPE:
19884 case SUBSTITUTABLE:
19885 case SUCCESSFUL:
19886 case SYSDATE:
19887 case SYS_REFCURSOR:
19888 case TEMPORARY:
19889 case TIME:
19890 case TIMESTAMP:
19891 case TIMEZONE_REGION:
19892 case TIMEZONE_ABBR:
19893 case TIMEZONE_MINUTE:
19894 case TIMEZONE_HOUR:
19895 case TRANSACTION:
19896 case TRUE:
19897 case TYPE:
19898 case UNDER:
19899 case USING:
19900 case YES:
19901 case SHOW:
19902 case A:
19903 case DOUBLE:
19904 case DEC:
19905 case PRECISION:
19906 case INT:
19907 case NUMERIC:
19908 case NCHAR:
19909 case NVARCHAR2:
19910 case STRING:
19911 case UROWID:
19912 case VARRAY:
19913 case VARYING:
19914 case BFILE:
19915 case BLOB:
19916 case CLOB:
19917 case NCLOB:
19918 case YEAR:
19919 case LOCAL:
19920 case ZONE:
19921 case CHARACTER:
19922 case AFTER:
19923 case BEFORE:
19924 case OLD:
19925 case PARENT:
19926 case ANALYZE:
19927 case ASSOCIATE:
19928 case AUDIT:
19929 case COMPOUND:
19930 case DATABASE:
19931 case CALL:
19932 case DDL:
19933 case DISASSOCIATE:
19934 case EACH:
19935 case FOLLOWS:
19936 case LOGOFF:
19937 case LOGON:
19938 case NESTED:
19939 case NOAUDIT:
19940 case SCHEMA:
19941 case SERVERERROR:
19942 case SHUTDOWN:
19943 case STARTUP:
19944 case STATEMENT:
19945 case STATISTICS:
19946 case SUSPEND:
19947 case TRUNCATE:
19948 case WRAPPED:
19949 case LIBRARY:
19950 case NAME:
19951 case STRUCT:
19952 case CONTEXT:
19953 case PARAMETERS:
19954 case LENGTH:
19955 case TDO:
19956 case MAXLEN:
19957 case CHARSETID:
19958 case CHARSETFORM:
19959 case ACCEPT:
19960 case ACCESSIBLE:
19961 case COPY:
19962 case DEFINE:
19963 case DISCONNECT:
19964 case HOST:
19965 case PRINT:
19966 case QUIT:
19967 case REMARK:
19968 case UNDEFINE:
19969 case VARIABLE:
19970 case WHENEVER:
19971 case ATTACH:
19972 case CAST:
19973 case TREAT:
19974 case TRIM:
19975 case LEFT:
19976 case RIGHT:
19977 case BOTH:
19978 case EMPTY:
19979 case MULTISET:
19980 case SUBMULTISET:
19981 case LEADING:
19982 case TRAILING:
19983 case CHAR_CS:
19984 case NCHAR_CS:
19985 case DBTIMEZONE:
19986 case SESSIONTIMEZONE:
19987 case AUTHENTICATED:
19988 case LINK:
19989 case SHARED:
19990 case DIRECTORY:
19991 case USER:
19992 case IDENTIFIER:
19993 case QUOTED_LITERAL:
19994 simpleNode = Name();
19995 sb.append(simpleNode.getImage()) ;
19996 break;
19997 default:
19998 jj_la1[264] = jj_gen;
19999 if (jj_2_53(2147483647)) {
20000 jj_consume_token(SELECT);
20001 sb.append("SELECT ...");
20002 Skip2NextTerminator(null,";");
20003 } else if (jj_2_54(2147483647)) {
20004 jj_consume_token(5);
20005 sb.append("(SELECT ...");
20006 Skip2NextTerminator("(",")");
20007 jj_consume_token(7);
20008 } else if (jj_2_55(2147483647)) {
20009 jj_consume_token(WITH);
20010 sb.append("WITH ...");
20011 Skip2NextTerminator(null,";");
20012 } else if (jj_2_56(2147483647)) {
20013 jj_consume_token(5);
20014 sb.append("(WITH ...");
20015 Skip2NextTerminator("(",")");
20016 jj_consume_token(7);
20017 } else {
20018 switch (jj_nt.kind) {
20019 case 5:
20020 jj_consume_token(5);
20021 sb.append("(");
20022 simpleNode = Expression();
20023 sb.append(simpleNode.getImage());
20024 label_63:
20025 while (true) {
20026 switch (jj_nt.kind) {
20027 case 6:
20028 ;
20029 break;
20030 default:
20031 jj_la1[262] = jj_gen;
20032 break label_63;
20033 }
20034 jj_consume_token(6);
20035 sb.append(", ");
20036 simpleNode = Expression();
20037 sb.append(simpleNode.getImage());
20038 }
20039 jj_consume_token(7);
20040 sb.append(")");
20041 break;
20042 default:
20043 jj_la1[265] = jj_gen;
20044 jj_consume_token(-1);
20045 throw new ParseException();
20046 }
20047 }
20048 }
20049 }
20050 }
20051 jjtree.closeNodeScope(jjtn000, true);
20052 jjtc000 = false;
20053 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
20054 } catch (Throwable jjte000) {
20055 if (jjtc000) {
20056 jjtree.clearNodeScope(jjtn000);
20057 jjtc000 = false;
20058 } else {
20059 jjtree.popNode();
20060 }
20061 if (jjte000 instanceof RuntimeException) {
20062 {if (true) throw (RuntimeException)jjte000;}
20063 }
20064 if (jjte000 instanceof ParseException) {
20065 {if (true) throw (ParseException)jjte000;}
20066 }
20067 {if (true) throw (Error)jjte000;}
20068 } finally {
20069 if (jjtc000) {
20070 jjtree.closeNodeScope(jjtn000, true);
20071 }
20072 }
20073 throw new Error("Missing return statement in function");
20074 }
20075
20076 final public ASTPrimarySuffix PrimarySuffix() throws ParseException {
20077
20078 ASTPrimarySuffix jjtn000 = new ASTPrimarySuffix(this, JJTPRIMARYSUFFIX);
20079 boolean jjtc000 = true;
20080 jjtree.openNodeScope(jjtn000);PLSQLNode suffixNode = null ; PLSQLNode arguments = null; StringBuilder sb = new StringBuilder() ;
20081 try {
20082 switch (jj_nt.kind) {
20083 case 3:
20084 jj_consume_token(3);
20085 sb.append(".");
20086 suffixNode = QualifiedID();
20087 sb.append(suffixNode.toString()) ;
20088 break;
20089 case 2:
20090 jj_consume_token(2);
20091 sb.append("@");
20092 suffixNode = QualifiedID();
20093 sb.append(suffixNode.toString()) ;
20094 break;
20095 case AT:
20096 jj_consume_token(AT);
20097 sb.append(" "); sb.append(token.image.toUpperCase());
20098 switch (jj_nt.kind) {
20099 case LOCAL:
20100 jj_consume_token(LOCAL);
20101 sb.append(" "); sb.append(token.image.toUpperCase());
20102 break;
20103 case TIME:
20104 jj_consume_token(TIME);
20105 jj_consume_token(ZONE);
20106 sb.append(" TIME ZONE");
20107 switch (jj_nt.kind) {
20108 case DBTIMEZONE:
20109 jj_consume_token(DBTIMEZONE);
20110 sb.append(" "); sb.append(token.image.toUpperCase());
20111 break;
20112 case SESSIONTIMEZONE:
20113 jj_consume_token(SESSIONTIMEZONE);
20114 sb.append(" "); sb.append(token.image.toUpperCase());
20115 break;
20116 case STRING_LITERAL:
20117 suffixNode = StringLiteral();
20118 sb.append(" "); sb.append(suffixNode.toString());
20119 break;
20120 case 5:
20121 case 16:
20122 case 17:
20123 case REPLACE:
20124 case DEFINER:
20125 case CURRENT_USER:
20126 case LANGUAGE:
20127 case INLINE:
20128 case ADD:
20129 case AGGREGATE:
20130 case ARRAY:
20131 case AT:
20132 case ATTRIBUTE:
20133 case AUTHID:
20134 case BODY:
20135 case BULK:
20136 case BYTE:
20137 case CASCADE:
20138 case CASE:
20139 case CLOSE:
20140 case COALESCE:
20141 case COLLECT:
20142 case COLUMN:
20143 case COMMENT:
20144 case COMMIT:
20145 case CONSTRUCTOR:
20146 case CONTINUE:
20147 case CONVERT:
20148 case CURRENT:
20149 case CURSOR:
20150 case DATA:
20151 case DATE:
20152 case DAY:
20153 case DISABLE:
20154 case EDITIONABLE:
20155 case ELEMENT:
20156 case ENABLE:
20157 case ESCAPE:
20158 case EXCEPT:
20159 case EXCEPTIONS:
20160 case EXIT:
20161 case EXTERNAL:
20162 case EXTENDS:
20163 case EXTRACT:
20164 case FALSE:
20165 case FINAL:
20166 case FORCE:
20167 case FUNCTION:
20168 case GLOBAL:
20169 case HASH:
20170 case HEAP:
20171 case HOUR:
20172 case IMMEDIATE:
20173 case INDICES:
20174 case INDEXTYPE:
20175 case INDICATOR:
20176 case INSTANTIABLE:
20177 case INTERVAL:
20178 case INVALIDATE:
20179 case ISOLATION:
20180 case JAVA:
20181 case LEVEL:
20182 case LIMIT:
20183 case LOOP:
20184 case MAP:
20185 case MAX:
20186 case MEMBER:
20187 case MERGE:
20188 case MIN:
20189 case MINUTE:
20190 case MLSLABEL:
20191 case MODIFY:
20192 case MOD:
20193 case MONTH:
20194 case NATURAL:
20195 case NEW:
20196 case NEW_DOT:
20197 case NO:
20198 case NONEDITIONABLE:
20199 case NOT:
20200 case NULL:
20201 case NULLIF:
20202 case OBJECT:
20203 case OID:
20204 case OPAQUE:
20205 case OPEN:
20206 case OPERATOR:
20207 case ORGANIZATION:
20208 case OTHERS:
20209 case OVERRIDING:
20210 case PACKAGE:
20211 case PARTITION:
20212 case PRESERVE:
20213 case PRIVATE:
20214 case PROCEDURE:
20215 case RANGE:
20216 case RAW:
20217 case REAL:
20218 case RECORD:
20219 case REF:
20220 case RELEASE:
20221 case RELIES_ON:
20222 case RENAME:
20223 case RESULT:
20224 case RETURN:
20225 case RETURNING:
20226 case REVERSE:
20227 case ROLLBACK:
20228 case ROW:
20229 case ROWS:
20230 case ROWID:
20231 case ROWNUM:
20232 case SAVE:
20233 case SAVEPOINT:
20234 case SECOND:
20235 case SELECT:
20236 case SELF:
20237 case SET:
20238 case SPACE:
20239 case SQL:
20240 case SQLCODE:
20241 case SQLERRM:
20242 case STATIC:
20243 case SUBTYPE:
20244 case SUBSTITUTABLE:
20245 case SUCCESSFUL:
20246 case SYSDATE:
20247 case SYS_REFCURSOR:
20248 case TEMPORARY:
20249 case TIME:
20250 case TIMESTAMP:
20251 case TIMEZONE_REGION:
20252 case TIMEZONE_ABBR:
20253 case TIMEZONE_MINUTE:
20254 case TIMEZONE_HOUR:
20255 case TRANSACTION:
20256 case TRUE:
20257 case TYPE:
20258 case UNDER:
20259 case USING:
20260 case YES:
20261 case SHOW:
20262 case A:
20263 case DOUBLE:
20264 case DEC:
20265 case PRECISION:
20266 case INT:
20267 case NUMERIC:
20268 case NCHAR:
20269 case NVARCHAR2:
20270 case STRING:
20271 case UROWID:
20272 case VARRAY:
20273 case VARYING:
20274 case BFILE:
20275 case BLOB:
20276 case CLOB:
20277 case NCLOB:
20278 case YEAR:
20279 case LOCAL:
20280 case WITH:
20281 case ZONE:
20282 case CHARACTER:
20283 case AFTER:
20284 case BEFORE:
20285 case OLD:
20286 case PARENT:
20287 case CC_IF:
20288 case ANALYZE:
20289 case ASSOCIATE:
20290 case AUDIT:
20291 case COMPOUND:
20292 case DATABASE:
20293 case CALL:
20294 case DDL:
20295 case DISASSOCIATE:
20296 case EACH:
20297 case FOLLOWS:
20298 case LOGOFF:
20299 case LOGON:
20300 case NESTED:
20301 case NOAUDIT:
20302 case SCHEMA:
20303 case SERVERERROR:
20304 case SHUTDOWN:
20305 case STARTUP:
20306 case STATEMENT:
20307 case STATISTICS:
20308 case SUSPEND:
20309 case TRUNCATE:
20310 case WRAPPED:
20311 case LIBRARY:
20312 case NAME:
20313 case STRUCT:
20314 case CONTEXT:
20315 case PARAMETERS:
20316 case LENGTH:
20317 case TDO:
20318 case MAXLEN:
20319 case CHARSETID:
20320 case CHARSETFORM:
20321 case ACCEPT:
20322 case ACCESSIBLE:
20323 case COPY:
20324 case DEFINE:
20325 case DISCONNECT:
20326 case HOST:
20327 case PRINT:
20328 case QUIT:
20329 case REMARK:
20330 case UNDEFINE:
20331 case VARIABLE:
20332 case WHENEVER:
20333 case ATTACH:
20334 case CAST:
20335 case TREAT:
20336 case TRIM:
20337 case LEFT:
20338 case RIGHT:
20339 case BOTH:
20340 case EMPTY:
20341 case MULTISET:
20342 case SUBMULTISET:
20343 case LEADING:
20344 case TRAILING:
20345 case CHAR_CS:
20346 case NCHAR_CS:
20347 case AUTHENTICATED:
20348 case LINK:
20349 case SHARED:
20350 case DIRECTORY:
20351 case USER:
20352 case IDENTIFIER:
20353 case UNSIGNED_NUMERIC_LITERAL:
20354 case CHARACTER_LITERAL:
20355 case QUOTED_LITERAL:
20356 suffixNode = Expression();
20357 sb.append(" "); sb.append(suffixNode.toString());
20358 break;
20359 default:
20360 jj_la1[266] = jj_gen;
20361 jj_consume_token(-1);
20362 throw new ParseException();
20363 }
20364 break;
20365 default:
20366 jj_la1[267] = jj_gen;
20367 jj_consume_token(-1);
20368 throw new ParseException();
20369 }
20370 break;
20371 case 5:
20372 arguments = Arguments();
20373 sb.append(arguments) ;
20374 break;
20375 default:
20376 jj_la1[268] = jj_gen;
20377 jj_consume_token(-1);
20378 throw new ParseException();
20379 }
20380 jjtree.closeNodeScope(jjtn000, true);
20381 jjtc000 = false;
20382 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
20383 } catch (Throwable jjte000) {
20384 if (jjtc000) {
20385 jjtree.clearNodeScope(jjtn000);
20386 jjtc000 = false;
20387 } else {
20388 jjtree.popNode();
20389 }
20390 if (jjte000 instanceof RuntimeException) {
20391 {if (true) throw (RuntimeException)jjte000;}
20392 }
20393 if (jjte000 instanceof ParseException) {
20394 {if (true) throw (ParseException)jjte000;}
20395 }
20396 {if (true) throw (Error)jjte000;}
20397 } finally {
20398 if (jjtc000) {
20399 jjtree.closeNodeScope(jjtn000, true);
20400 }
20401 }
20402 throw new Error("Missing return statement in function");
20403 }
20404
20405 final public ASTLiteral Literal() throws ParseException {
20406
20407 ASTLiteral jjtn000 = new ASTLiteral(this, JJTLITERAL);
20408 boolean jjtc000 = true;
20409 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20410 Token t = null ;
20411 try {
20412 switch (jj_nt.kind) {
20413 case UNSIGNED_NUMERIC_LITERAL:
20414 simpleNode = NumericLiteral();
20415 break;
20416 case CHARACTER_LITERAL:
20417 t = jj_consume_token(CHARACTER_LITERAL);
20418 break;
20419 case STRING_LITERAL:
20420
20421 simpleNode = StringLiteral();
20422 break;
20423 case FALSE:
20424 case TRUE:
20425 simpleNode = BooleanLiteral();
20426 break;
20427 case NULL:
20428 simpleNode = NullLiteral();
20429 break;
20430 case DATE:
20431 case INTERVAL:
20432 case TIMESTAMP:
20433 simpleNode = DateTimeLiteral();
20434 break;
20435 default:
20436 jj_la1[269] = jj_gen;
20437 jj_consume_token(-1);
20438 throw new ParseException();
20439 }
20440 jjtree.closeNodeScope(jjtn000, true);
20441 jjtc000 = false;
20442 if (null != simpleNode)
20443 {
20444 jjtn000.setImage( simpleNode.getImage() ) ;
20445 }
20446 else if (null != t)
20447 {
20448 jjtn000.setImage( t.image ) ;
20449 }
20450 {if (true) return jjtn000 ;}
20451 } catch (Throwable jjte000) {
20452 if (jjtc000) {
20453 jjtree.clearNodeScope(jjtn000);
20454 jjtc000 = false;
20455 } else {
20456 jjtree.popNode();
20457 }
20458 if (jjte000 instanceof RuntimeException) {
20459 {if (true) throw (RuntimeException)jjte000;}
20460 }
20461 if (jjte000 instanceof ParseException) {
20462 {if (true) throw (ParseException)jjte000;}
20463 }
20464 {if (true) throw (Error)jjte000;}
20465 } finally {
20466 if (jjtc000) {
20467 jjtree.closeNodeScope(jjtn000, true);
20468 }
20469 }
20470 throw new Error("Missing return statement in function");
20471 }
20472
20473 final public ASTStringLiteral StringLiteral() throws ParseException {
20474
20475 ASTStringLiteral jjtn000 = new ASTStringLiteral(this, JJTSTRINGLITERAL);
20476 boolean jjtc000 = true;
20477 jjtree.openNodeScope(jjtn000);Token thisToken = null;
20478 StringBuilder literal = new StringBuilder() ;
20479 char startDelimiter ;
20480 char endDelimiter ;
20481 String terminator = null;
20482 try {
20483 thisToken = jj_consume_token(STRING_LITERAL);
20484 literal.append(thisToken.image);
20485
20486
20487
20488
20489
20490 if (thisToken.image.toUpperCase().startsWith("Q'")
20491 && thisToken.image.length() > 2
20492 )
20493 {
20494
20495
20496 startDelimiter= thisToken.image.charAt(2) ;
20497
20498
20499
20500
20501 switch (startDelimiter)
20502 {
20503 case '<' : endDelimiter = '>' ; break ;
20504 case '{' : endDelimiter = '}' ; break ;
20505 case '(' : endDelimiter = ')' ; break ;
20506 case '[' : endDelimiter = ']' ; break ;
20507 default: endDelimiter = startDelimiter ;
20508 }
20509
20510 terminator = new String(endDelimiter + "'");
20511 if (!thisToken.image.endsWith(terminator))
20512 {
20513
20514 literal.append(ReadPastNextOccurrence(terminator));
20515 }
20516 }
20517 jjtree.closeNodeScope(jjtn000, true);
20518 jjtc000 = false;
20519 jjtn000.setImage(literal.toString()) ; jjtn000.value = literal.toString() ; {if (true) return jjtn000 ;}
20520 } finally {
20521 if (jjtc000) {
20522 jjtree.closeNodeScope(jjtn000, true);
20523 }
20524 }
20525 throw new Error("Missing return statement in function");
20526 }
20527
20528 final public ASTBooleanLiteral BooleanLiteral() throws ParseException {
20529
20530 ASTBooleanLiteral jjtn000 = new ASTBooleanLiteral(this, JJTBOOLEANLITERAL);
20531 boolean jjtc000 = true;
20532 jjtree.openNodeScope(jjtn000);
20533 try {
20534 switch (jj_nt.kind) {
20535 case TRUE:
20536 jj_consume_token(TRUE);
20537 break;
20538 case FALSE:
20539 jj_consume_token(FALSE);
20540 break;
20541 default:
20542 jj_la1[270] = jj_gen;
20543 jj_consume_token(-1);
20544 throw new ParseException();
20545 }
20546 jjtree.closeNodeScope(jjtn000, true);
20547 jjtc000 = false;
20548 jjtn000.setImage(token.image) ;
20549 {if (true) return jjtn000;}
20550 } finally {
20551 if (jjtc000) {
20552 jjtree.closeNodeScope(jjtn000, true);
20553 }
20554 }
20555 throw new Error("Missing return statement in function");
20556 }
20557
20558 final public ASTNullLiteral NullLiteral() throws ParseException {
20559
20560 ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL);
20561 boolean jjtc000 = true;
20562 jjtree.openNodeScope(jjtn000);
20563 try {
20564 jj_consume_token(NULL);
20565 jjtree.closeNodeScope(jjtn000, true);
20566 jjtc000 = false;
20567 jjtn000.setImage(token.image) ;
20568 {if (true) return jjtn000 ;}
20569 } finally {
20570 if (jjtc000) {
20571 jjtree.closeNodeScope(jjtn000, true);
20572 }
20573 }
20574 throw new Error("Missing return statement in function");
20575 }
20576
20577 final public ASTMultiSetCondition MultiSetCondition() throws ParseException {
20578
20579 ASTMultiSetCondition jjtn000 = new ASTMultiSetCondition(this, JJTMULTISETCONDITION);
20580 boolean jjtc000 = true;
20581 jjtree.openNodeScope(jjtn000);
20582 try {
20583 switch (jj_nt.kind) {
20584 case A:
20585 jj_consume_token(A);
20586 jj_consume_token(SET);
20587 break;
20588 case EMPTY:
20589 jj_consume_token(EMPTY);
20590 break;
20591 default:
20592 jj_la1[271] = jj_gen;
20593 jj_consume_token(-1);
20594 throw new ParseException();
20595 }
20596 jjtree.closeNodeScope(jjtn000, true);
20597 jjtc000 = false;
20598 {if (true) return jjtn000;}
20599 } finally {
20600 if (jjtc000) {
20601 jjtree.closeNodeScope(jjtn000, true);
20602 }
20603 }
20604 throw new Error("Missing return statement in function");
20605 }
20606
20607
20608
20609
20610
20611
20612 final public ASTNumericLiteral NumericLiteral() throws ParseException {
20613
20614 ASTNumericLiteral jjtn000 = new ASTNumericLiteral(this, JJTNUMERICLITERAL);
20615 boolean jjtc000 = true;
20616 jjtree.openNodeScope(jjtn000);Token t = null ;
20617 try {
20618
20619 t = jj_consume_token(UNSIGNED_NUMERIC_LITERAL);
20620 jjtree.closeNodeScope(jjtn000, true);
20621 jjtc000 = false;
20622 jjtn000.setImage(t.image) ;
20623 {if (true) return jjtn000;}
20624 } finally {
20625 if (jjtc000) {
20626 jjtree.closeNodeScope(jjtn000, true);
20627 }
20628 }
20629 throw new Error("Missing return statement in function");
20630 }
20631
20632
20633
20634 final public ASTLabel Label() throws ParseException {
20635
20636 ASTLabel jjtn000 = new ASTLabel(this, JJTLABEL);
20637 boolean jjtc000 = true;
20638 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20639 try {
20640 jj_consume_token(21);
20641 simpleNode = UnqualifiedID();
20642 jj_consume_token(22);
20643 jjtree.closeNodeScope(jjtn000, true);
20644 jjtc000 = false;
20645 jjtn000.setImage( simpleNode.getImage() ) ;
20646 {if (true) return jjtn000;}
20647 } catch (Throwable jjte000) {
20648 if (jjtc000) {
20649 jjtree.clearNodeScope(jjtn000);
20650 jjtc000 = false;
20651 } else {
20652 jjtree.popNode();
20653 }
20654 if (jjte000 instanceof RuntimeException) {
20655 {if (true) throw (RuntimeException)jjte000;}
20656 }
20657 if (jjte000 instanceof ParseException) {
20658 {if (true) throw (ParseException)jjte000;}
20659 }
20660 {if (true) throw (Error)jjte000;}
20661 } finally {
20662 if (jjtc000) {
20663 jjtree.closeNodeScope(jjtn000, true);
20664 }
20665 }
20666 throw new Error("Missing return statement in function");
20667 }
20668
20669 final public ASTName Name() throws ParseException {
20670
20671 ASTName jjtn000 = new ASTName(this, JJTNAME);
20672 boolean jjtc000 = true;
20673 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20674 StringBuilder sb = new StringBuilder();
20675 try {
20676 simpleNode = UnqualifiedID();
20677 sb.append(simpleNode.getImage()) ;
20678 label_64:
20679 while (true) {
20680 if (jj_2_57(2)) {
20681 ;
20682 } else {
20683 break label_64;
20684 }
20685 switch (jj_nt.kind) {
20686 case 3:
20687 jj_consume_token(3);
20688 sb.append(".") ;
20689 break;
20690 case 11:
20691 jj_consume_token(11);
20692 sb.append("%") ;
20693 break;
20694 default:
20695 jj_la1[272] = jj_gen;
20696 jj_consume_token(-1);
20697 throw new ParseException();
20698 }
20699
20700 simpleNode = QualifiedID();
20701 sb.append(simpleNode.getImage()) ;
20702 }
20703 jjtree.closeNodeScope(jjtn000, true);
20704 jjtc000 = false;
20705 jjtn000.setImage(sb.toString()) ;
20706 {if (true) return jjtn000;}
20707 } catch (Throwable jjte000) {
20708 if (jjtc000) {
20709 jjtree.clearNodeScope(jjtn000);
20710 jjtc000 = false;
20711 } else {
20712 jjtree.popNode();
20713 }
20714 if (jjte000 instanceof RuntimeException) {
20715 {if (true) throw (RuntimeException)jjte000;}
20716 }
20717 if (jjte000 instanceof ParseException) {
20718 {if (true) throw (ParseException)jjte000;}
20719 }
20720 {if (true) throw (Error)jjte000;}
20721 } finally {
20722 if (jjtc000) {
20723 jjtree.closeNodeScope(jjtn000, true);
20724 }
20725 }
20726 throw new Error("Missing return statement in function");
20727 }
20728
20729 final public ASTQualifiedName QualifiedName() throws ParseException {
20730
20731 ASTQualifiedName jjtn000 = new ASTQualifiedName(this, JJTQUALIFIEDNAME);
20732 boolean jjtc000 = true;
20733 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20734 StringBuilder sb = new StringBuilder();
20735 try {
20736 simpleNode = UnqualifiedID();
20737 sb.append(simpleNode.getImage()) ;
20738 label_65:
20739 while (true) {
20740 switch (jj_nt.kind) {
20741 case 3:
20742 ;
20743 break;
20744 default:
20745 jj_la1[273] = jj_gen;
20746 break label_65;
20747 }
20748 jj_consume_token(3);
20749 simpleNode = QualifiedID();
20750 sb.append(".") ; sb.append(simpleNode.getImage()) ;
20751 }
20752 jjtree.closeNodeScope(jjtn000, true);
20753 jjtc000 = false;
20754 jjtn000.setImage(sb.toString()) ;
20755 {if (true) return jjtn000 ;}
20756 } catch (Throwable jjte000) {
20757 if (jjtc000) {
20758 jjtree.clearNodeScope(jjtn000);
20759 jjtc000 = false;
20760 } else {
20761 jjtree.popNode();
20762 }
20763 if (jjte000 instanceof RuntimeException) {
20764 {if (true) throw (RuntimeException)jjte000;}
20765 }
20766 if (jjte000 instanceof ParseException) {
20767 {if (true) throw (ParseException)jjte000;}
20768 }
20769 {if (true) throw (Error)jjte000;}
20770 } finally {
20771 if (jjtc000) {
20772 jjtree.closeNodeScope(jjtn000, true);
20773 }
20774 }
20775 throw new Error("Missing return statement in function");
20776 }
20777
20778 final public ASTArguments Arguments() throws ParseException {
20779
20780 ASTArguments jjtn000 = new ASTArguments(this, JJTARGUMENTS);
20781 boolean jjtc000 = true;
20782 jjtree.openNodeScope(jjtn000);
20783 try {
20784 jj_consume_token(5);
20785 switch (jj_nt.kind) {
20786 case 5:
20787 case 16:
20788 case 17:
20789 case REPLACE:
20790 case DEFINER:
20791 case CURRENT_USER:
20792 case LANGUAGE:
20793 case INLINE:
20794 case ADD:
20795 case AGGREGATE:
20796 case ARRAY:
20797 case AT:
20798 case ATTRIBUTE:
20799 case AUTHID:
20800 case BODY:
20801 case BULK:
20802 case BYTE:
20803 case CASCADE:
20804 case CASE:
20805 case CLOSE:
20806 case COALESCE:
20807 case COLLECT:
20808 case COLUMN:
20809 case COMMENT:
20810 case COMMIT:
20811 case CONSTRUCTOR:
20812 case CONTINUE:
20813 case CONVERT:
20814 case CURRENT:
20815 case CURSOR:
20816 case DATA:
20817 case DATE:
20818 case DAY:
20819 case DISABLE:
20820 case EDITIONABLE:
20821 case ELEMENT:
20822 case ENABLE:
20823 case ESCAPE:
20824 case EXCEPT:
20825 case EXCEPTIONS:
20826 case EXIT:
20827 case EXTERNAL:
20828 case EXTENDS:
20829 case EXTRACT:
20830 case FALSE:
20831 case FINAL:
20832 case FORCE:
20833 case FUNCTION:
20834 case GLOBAL:
20835 case HASH:
20836 case HEAP:
20837 case HOUR:
20838 case IMMEDIATE:
20839 case INDICES:
20840 case INDEXTYPE:
20841 case INDICATOR:
20842 case INSTANTIABLE:
20843 case INTERVAL:
20844 case INVALIDATE:
20845 case ISOLATION:
20846 case JAVA:
20847 case LEVEL:
20848 case LIMIT:
20849 case LOOP:
20850 case MAP:
20851 case MAX:
20852 case MEMBER:
20853 case MERGE:
20854 case MIN:
20855 case MINUTE:
20856 case MLSLABEL:
20857 case MODIFY:
20858 case MOD:
20859 case MONTH:
20860 case NATURAL:
20861 case NEW:
20862 case NEW_DOT:
20863 case NO:
20864 case NONEDITIONABLE:
20865 case NOT:
20866 case NULL:
20867 case NULLIF:
20868 case OBJECT:
20869 case OID:
20870 case OPAQUE:
20871 case OPEN:
20872 case OPERATOR:
20873 case ORGANIZATION:
20874 case OTHERS:
20875 case OVERRIDING:
20876 case PACKAGE:
20877 case PARTITION:
20878 case PRESERVE:
20879 case PRIVATE:
20880 case PROCEDURE:
20881 case RANGE:
20882 case RAW:
20883 case REAL:
20884 case RECORD:
20885 case REF:
20886 case RELEASE:
20887 case RELIES_ON:
20888 case RENAME:
20889 case RESULT:
20890 case RETURN:
20891 case RETURNING:
20892 case REVERSE:
20893 case ROLLBACK:
20894 case ROW:
20895 case ROWS:
20896 case ROWID:
20897 case ROWNUM:
20898 case SAVE:
20899 case SAVEPOINT:
20900 case SECOND:
20901 case SELECT:
20902 case SELF:
20903 case SET:
20904 case SPACE:
20905 case SQL:
20906 case SQLCODE:
20907 case SQLERRM:
20908 case STATIC:
20909 case SUBTYPE:
20910 case SUBSTITUTABLE:
20911 case SUCCESSFUL:
20912 case SYSDATE:
20913 case SYS_REFCURSOR:
20914 case TEMPORARY:
20915 case TIME:
20916 case TIMESTAMP:
20917 case TIMEZONE_REGION:
20918 case TIMEZONE_ABBR:
20919 case TIMEZONE_MINUTE:
20920 case TIMEZONE_HOUR:
20921 case TRANSACTION:
20922 case TRUE:
20923 case TYPE:
20924 case UNDER:
20925 case USING:
20926 case YES:
20927 case SHOW:
20928 case A:
20929 case DOUBLE:
20930 case DEC:
20931 case PRECISION:
20932 case INT:
20933 case NUMERIC:
20934 case NCHAR:
20935 case NVARCHAR2:
20936 case STRING:
20937 case UROWID:
20938 case VARRAY:
20939 case VARYING:
20940 case BFILE:
20941 case BLOB:
20942 case CLOB:
20943 case NCLOB:
20944 case YEAR:
20945 case LOCAL:
20946 case WITH:
20947 case ZONE:
20948 case CHARACTER:
20949 case AFTER:
20950 case BEFORE:
20951 case OLD:
20952 case PARENT:
20953 case CC_IF:
20954 case ANALYZE:
20955 case ASSOCIATE:
20956 case AUDIT:
20957 case COMPOUND:
20958 case DATABASE:
20959 case CALL:
20960 case DDL:
20961 case DISASSOCIATE:
20962 case EACH:
20963 case FOLLOWS:
20964 case LOGOFF:
20965 case LOGON:
20966 case NESTED:
20967 case NOAUDIT:
20968 case SCHEMA:
20969 case SERVERERROR:
20970 case SHUTDOWN:
20971 case STARTUP:
20972 case STATEMENT:
20973 case STATISTICS:
20974 case SUSPEND:
20975 case TRUNCATE:
20976 case WRAPPED:
20977 case LIBRARY:
20978 case NAME:
20979 case STRUCT:
20980 case CONTEXT:
20981 case PARAMETERS:
20982 case LENGTH:
20983 case TDO:
20984 case MAXLEN:
20985 case CHARSETID:
20986 case CHARSETFORM:
20987 case ACCEPT:
20988 case ACCESSIBLE:
20989 case COPY:
20990 case DEFINE:
20991 case DISCONNECT:
20992 case HOST:
20993 case PRINT:
20994 case QUIT:
20995 case REMARK:
20996 case UNDEFINE:
20997 case VARIABLE:
20998 case WHENEVER:
20999 case ATTACH:
21000 case CAST:
21001 case TREAT:
21002 case TRIM:
21003 case LEFT:
21004 case RIGHT:
21005 case BOTH:
21006 case EMPTY:
21007 case MULTISET:
21008 case SUBMULTISET:
21009 case LEADING:
21010 case TRAILING:
21011 case CHAR_CS:
21012 case NCHAR_CS:
21013 case DBTIMEZONE:
21014 case SESSIONTIMEZONE:
21015 case AUTHENTICATED:
21016 case LINK:
21017 case SHARED:
21018 case DIRECTORY:
21019 case USER:
21020 case IDENTIFIER:
21021 case UNSIGNED_NUMERIC_LITERAL:
21022 case CHARACTER_LITERAL:
21023 case STRING_LITERAL:
21024 case QUOTED_LITERAL:
21025 ArgumentList();
21026 break;
21027 default:
21028 jj_la1[274] = jj_gen;
21029 ;
21030 }
21031 jj_consume_token(7);
21032 jjtree.closeNodeScope(jjtn000, true);
21033 jjtc000 = false;
21034 {if (true) return jjtn000 ;}
21035 } catch (Throwable jjte000) {
21036 if (jjtc000) {
21037 jjtree.clearNodeScope(jjtn000);
21038 jjtc000 = false;
21039 } else {
21040 jjtree.popNode();
21041 }
21042 if (jjte000 instanceof RuntimeException) {
21043 {if (true) throw (RuntimeException)jjte000;}
21044 }
21045 if (jjte000 instanceof ParseException) {
21046 {if (true) throw (ParseException)jjte000;}
21047 }
21048 {if (true) throw (Error)jjte000;}
21049 } finally {
21050 if (jjtc000) {
21051 jjtree.closeNodeScope(jjtn000, true);
21052 }
21053 }
21054 throw new Error("Missing return statement in function");
21055 }
21056
21057 final public ASTArgumentList ArgumentList() throws ParseException {
21058
21059 ASTArgumentList jjtn000 = new ASTArgumentList(this, JJTARGUMENTLIST);
21060 boolean jjtc000 = true;
21061 jjtree.openNodeScope(jjtn000);
21062 try {
21063 Argument();
21064 label_66:
21065 while (true) {
21066 switch (jj_nt.kind) {
21067 case 6:
21068 ;
21069 break;
21070 default:
21071 jj_la1[275] = jj_gen;
21072 break label_66;
21073 }
21074 jj_consume_token(6);
21075 Argument();
21076 }
21077 jjtree.closeNodeScope(jjtn000, true);
21078 jjtc000 = false;
21079 {if (true) return jjtn000 ;}
21080 } catch (Throwable jjte000) {
21081 if (jjtc000) {
21082 jjtree.clearNodeScope(jjtn000);
21083 jjtc000 = false;
21084 } else {
21085 jjtree.popNode();
21086 }
21087 if (jjte000 instanceof RuntimeException) {
21088 {if (true) throw (RuntimeException)jjte000;}
21089 }
21090 if (jjte000 instanceof ParseException) {
21091 {if (true) throw (ParseException)jjte000;}
21092 }
21093 {if (true) throw (Error)jjte000;}
21094 } finally {
21095 if (jjtc000) {
21096 jjtree.closeNodeScope(jjtn000, true);
21097 }
21098 }
21099 throw new Error("Missing return statement in function");
21100 }
21101
21102 final public ASTArgument Argument() throws ParseException {
21103
21104 ASTArgument jjtn000 = new ASTArgument(this, JJTARGUMENT);
21105 boolean jjtc000 = true;
21106 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
21107 try {
21108 if (jj_2_58(2)) {
21109 simpleNode = UnqualifiedID();
21110 switch (jj_nt.kind) {
21111 case 23:
21112 jj_consume_token(23);
21113 break;
21114 case AS:
21115 jj_consume_token(AS);
21116 break;
21117 default:
21118 jj_la1[276] = jj_gen;
21119 jj_consume_token(-1);
21120 throw new ParseException();
21121 }
21122 } else {
21123 ;
21124 }
21125 Expression();
21126 switch (jj_nt.kind) {
21127 case USING:
21128 jj_consume_token(USING);
21129 switch (jj_nt.kind) {
21130 case CHAR_CS:
21131 jj_consume_token(CHAR_CS);
21132 break;
21133 case NCHAR_CS:
21134 jj_consume_token(NCHAR_CS);
21135 break;
21136 default:
21137 jj_la1[277] = jj_gen;
21138 jj_consume_token(-1);
21139 throw new ParseException();
21140 }
21141 break;
21142 default:
21143 jj_la1[278] = jj_gen;
21144 ;
21145 }
21146 jjtree.closeNodeScope(jjtn000, true);
21147 jjtc000 = false;
21148 if (null != simpleNode) { jjtn000.setImage(simpleNode.getImage()) ; }
21149 {if (true) return jjtn000 ;}
21150 } catch (Throwable jjte000) {
21151 if (jjtc000) {
21152 jjtree.clearNodeScope(jjtn000);
21153 jjtc000 = false;
21154 } else {
21155 jjtree.popNode();
21156 }
21157 if (jjte000 instanceof RuntimeException) {
21158 {if (true) throw (RuntimeException)jjte000;}
21159 }
21160 if (jjte000 instanceof ParseException) {
21161 {if (true) throw (ParseException)jjte000;}
21162 }
21163 {if (true) throw (Error)jjte000;}
21164 } finally {
21165 if (jjtc000) {
21166 jjtree.closeNodeScope(jjtn000, true);
21167 }
21168 }
21169 throw new Error("Missing return statement in function");
21170 }
21171
21172
21173
21174
21175 final public ASTVariableOrConstantDeclaration VariableOrConstantDeclaration() throws ParseException {
21176
21177 ASTVariableOrConstantDeclaration jjtn000 = new ASTVariableOrConstantDeclaration(this, JJTVARIABLEORCONSTANTDECLARATION);
21178 boolean jjtc000 = true;
21179 jjtree.openNodeScope(jjtn000);
21180 try {
21181 VariableOrConstantDeclarator();
21182 jj_consume_token(4);
21183 jjtree.closeNodeScope(jjtn000, true);
21184 jjtc000 = false;
21185 {if (true) return jjtn000 ;}
21186 } catch (Throwable jjte000) {
21187 if (jjtc000) {
21188 jjtree.clearNodeScope(jjtn000);
21189 jjtc000 = false;
21190 } else {
21191 jjtree.popNode();
21192 }
21193 if (jjte000 instanceof RuntimeException) {
21194 {if (true) throw (RuntimeException)jjte000;}
21195 }
21196 if (jjte000 instanceof ParseException) {
21197 {if (true) throw (ParseException)jjte000;}
21198 }
21199 {if (true) throw (Error)jjte000;}
21200 } finally {
21201 if (jjtc000) {
21202 jjtree.closeNodeScope(jjtn000, true);
21203 }
21204 }
21205 throw new Error("Missing return statement in function");
21206 }
21207
21208 final public ASTDatatypeDeclaration DatatypeDeclaration() throws ParseException {
21209
21210 ASTDatatypeDeclaration jjtn000 = new ASTDatatypeDeclaration(this, JJTDATATYPEDECLARATION);
21211 boolean jjtc000 = true;
21212 jjtree.openNodeScope(jjtn000);Token t ;
21213 try {
21214 t = jj_consume_token(IDENTIFIER);
21215 jjtree.closeNodeScope(jjtn000, true);
21216 jjtc000 = false;
21217 jjtn000.setImage(t.image) ; {if (true) return jjtn000 ;}
21218 } finally {
21219 if (jjtc000) {
21220 jjtree.closeNodeScope(jjtn000, true);
21221 }
21222 }
21223 throw new Error("Missing return statement in function");
21224 }
21225
21226 final public ASTPragma Pragma() throws ParseException {
21227
21228 ASTPragma jjtn000 = new ASTPragma(this, JJTPRAGMA);
21229 boolean jjtc000 = true;
21230 jjtree.openNodeScope(jjtn000);
21231 try {
21232 jj_consume_token(PRAGMA);
21233 switch (jj_nt.kind) {
21234 case SERIALLY_REUSABLE:
21235 jj_consume_token(SERIALLY_REUSABLE);
21236 break;
21237 case AUTONOMOUS_TRANSACTION:
21238 jj_consume_token(AUTONOMOUS_TRANSACTION);
21239 break;
21240 case TIMESTAMP:
21241 jj_consume_token(TIMESTAMP);
21242 jj_consume_token(5);
21243 StringLiteral();
21244 jj_consume_token(7);
21245 break;
21246 case RESTRICT_REFERENCES:
21247 jj_consume_token(RESTRICT_REFERENCES);
21248 jj_consume_token(5);
21249 ID();
21250 label_67:
21251 while (true) {
21252 jj_consume_token(6);
21253 switch (jj_nt.kind) {
21254 case REPLACE:
21255 case DEFINER:
21256 case CURRENT_USER:
21257 case SERIALLY_REUSABLE:
21258 case RESTRICT_REFERENCES:
21259 case EXCEPTION_INIT:
21260 case AUTONOMOUS_TRANSACTION:
21261 case LANGUAGE:
21262 case INLINE:
21263 case ADD:
21264 case AGGREGATE:
21265 case ALL:
21266 case ALTER:
21267 case AND:
21268 case ANY:
21269 case ARRAY:
21270 case AS:
21271 case ASC:
21272 case AT:
21273 case ATTRIBUTE:
21274 case AUTHID:
21275 case AVG:
21276 case BETWEEN:
21277 case BINARY_INTEGER:
21278 case BODY:
21279 case BOOLEAN:
21280 case BULK:
21281 case BY:
21282 case BYTE:
21283 case CASCADE:
21284 case CASE:
21285 case CHAR:
21286 case CHAR_BASE:
21287 case CHECK:
21288 case CLOSE:
21289 case CLUSTER:
21290 case COALESCE:
21291 case COLLECT:
21292 case COLUMN:
21293 case COMMENT:
21294 case COMMIT:
21295 case COMPRESS:
21296 case CONNECT:
21297 case CONSTANT:
21298 case CONSTRUCTOR:
21299 case CONTINUE:
21300 case CONVERT:
21301 case CREATE:
21302 case CURRENT:
21303 case CURRVAL:
21304 case CURSOR:
21305 case DATA:
21306 case DATE:
21307 case DAY:
21308 case DECLARE:
21309 case DECIMAL:
21310 case _DEFAULT:
21311 case DELETE:
21312 case DESC:
21313 case DISABLE:
21314 case DISTINCT:
21315 case DO:
21316 case DROP:
21317 case EDITIONABLE:
21318 case ELEMENT:
21319 case ELSE:
21320 case ELSIF:
21321 case ENABLE:
21322 case ESCAPE:
21323 case EXCEPT:
21324 case EXCEPTION:
21325 case EXCEPTIONS:
21326 case EXCLUSIVE:
21327 case EXECUTE:
21328 case EXISTS:
21329 case EXIT:
21330 case EXTERNAL:
21331 case EXTENDS:
21332 case EXTRACT:
21333 case FALSE:
21334 case FETCH:
21335 case FINAL:
21336 case FLOAT:
21337 case FOR:
21338 case FORALL:
21339 case FORCE:
21340 case FROM:
21341 case FUNCTION:
21342 case GLOBAL:
21343 case GOTO:
21344 case GROUP:
21345 case HASH:
21346 case HAVING:
21347 case HEAP:
21348 case HOUR:
21349 case IF:
21350 case IMMEDIATE:
21351 case IN:
21352 case INDEX:
21353 case INDICES:
21354 case INDEXTYPE:
21355 case INDICATOR:
21356 case INSERT:
21357 case INSTANTIABLE:
21358 case INTEGER:
21359 case INTERFACE:
21360 case INTERSECT:
21361 case INTERVAL:
21362 case INTO:
21363 case INVALIDATE:
21364 case IS:
21365 case ISOLATION:
21366 case JAVA:
21367 case LEVEL:
21368 case LIKE:
21369 case LIMIT:
21370 case LIMITED:
21371 case LOCK:
21372 case LONG:
21373 case LOOP:
21374 case MAP:
21375 case MAX:
21376 case MEMBER:
21377 case MERGE:
21378 case MIN:
21379 case MINUS:
21380 case MINUTE:
21381 case MLSLABEL:
21382 case MODIFY:
21383 case MOD:
21384 case MODE:
21385 case MONTH:
21386 case NATURAL:
21387 case NATURALN:
21388 case NEW:
21389 case NEXTVAL:
21390 case NO:
21391 case NOCOPY:
21392 case NONEDITIONABLE:
21393 case NOT:
21394 case NOWAIT:
21395 case NULL:
21396 case NULLIF:
21397 case NUMBER:
21398 case BFILE_BASE:
21399 case BLOB_BASE:
21400 case CLOB_BASE:
21401 case DATE_BASE:
21402 case NUMBER_BASE:
21403 case OBJECT:
21404 case OCIROWID:
21405 case OF:
21406 case OID:
21407 case ON:
21408 case OPAQUE:
21409 case OPEN:
21410 case OPERATOR:
21411 case OPTION:
21412 case OR:
21413 case ORDER:
21414 case ORGANIZATION:
21415 case OTHERS:
21416 case OUT:
21417 case OVERRIDING:
21418 case PACKAGE:
21419 case PARTITION:
21420 case PCTFREE:
21421 case PLS_INTEGER:
21422 case POSITIVE:
21423 case POSITIVEN:
21424 case PRESERVE:
21425 case PRIOR:
21426 case PROMPT:
21427 case PRIVATE:
21428 case PROCEDURE:
21429 case PUBLIC:
21430 case RAISE:
21431 case RANGE:
21432 case RAW:
21433 case REAL:
21434 case RECORD:
21435 case REF:
21436 case RELEASE:
21437 case RELIES_ON:
21438 case RENAME:
21439 case RESULT:
21440 case RETURN:
21441 case RETURNING:
21442 case REVERSE:
21443 case ROLLBACK:
21444 case ROW:
21445 case ROWS:
21446 case ROWID:
21447 case ROWNUM:
21448 case ROWTYPE:
21449 case SAVE:
21450 case SAVEPOINT:
21451 case SECOND:
21452 case SELECT:
21453 case SELF:
21454 case SEPARATE:
21455 case SET:
21456 case SHARE:
21457 case SMALLINT:
21458 case SPACE:
21459 case SQL:
21460 case SQLCODE:
21461 case SQLERRM:
21462 case START:
21463 case STATIC:
21464 case STDDEV:
21465 case SUBTYPE:
21466 case SUBSTITUTABLE:
21467 case SUCCESSFUL:
21468 case SUM:
21469 case SYNONYM:
21470 case SYSDATE:
21471 case SYS_REFCURSOR:
21472 case TABLE:
21473 case TEMPORARY:
21474 case THEN:
21475 case TIME:
21476 case TIMESTAMP:
21477 case TIMEZONE_REGION:
21478 case TIMEZONE_ABBR:
21479 case TIMEZONE_MINUTE:
21480 case TIMEZONE_HOUR:
21481 case TO:
21482 case TRANSACTION:
21483 case TRIGGER:
21484 case TRUE:
21485 case TYPE:
21486 case UI:
21487 case UNDER:
21488 case USING:
21489 case WHILE:
21490 case YES:
21491 case SHOW:
21492 case A:
21493 case UPDATE:
21494 case VARCHAR:
21495 case VARCHAR2:
21496 case DOUBLE:
21497 case DEC:
21498 case PRECISION:
21499 case INT:
21500 case NUMERIC:
21501 case SIGNTYPE:
21502 case NCHAR:
21503 case NVARCHAR2:
21504 case STRING:
21505 case UROWID:
21506 case VARRAY:
21507 case VARYING:
21508 case BFILE:
21509 case BLOB:
21510 case CLOB:
21511 case NCLOB:
21512 case YEAR:
21513 case LOCAL:
21514 case WITH:
21515 case ZONE:
21516 case CHARACTER:
21517 case AFTER:
21518 case BEFORE:
21519 case OLD:
21520 case PARENT:
21521 case ANALYZE:
21522 case ASSOCIATE:
21523 case AUDIT:
21524 case COMPOUND:
21525 case DATABASE:
21526 case CALL:
21527 case DDL:
21528 case DISASSOCIATE:
21529 case EACH:
21530 case FOLLOWS:
21531 case LOGOFF:
21532 case LOGON:
21533 case NESTED:
21534 case NOAUDIT:
21535 case SCHEMA:
21536 case SERVERERROR:
21537 case SHUTDOWN:
21538 case STARTUP:
21539 case STATEMENT:
21540 case STATISTICS:
21541 case SUSPEND:
21542 case TRUNCATE:
21543 case WRAPPED:
21544 case LIBRARY:
21545 case NAME:
21546 case STRUCT:
21547 case CONTEXT:
21548 case PARAMETERS:
21549 case LENGTH:
21550 case TDO:
21551 case MAXLEN:
21552 case CHARSETID:
21553 case CHARSETFORM:
21554 case ACCEPT:
21555 case ACCESSIBLE:
21556 case COPY:
21557 case DEFINE:
21558 case DISCONNECT:
21559 case HOST:
21560 case PRINT:
21561 case QUIT:
21562 case REMARK:
21563 case UNDEFINE:
21564 case VARIABLE:
21565 case WHENEVER:
21566 case ATTACH:
21567 case CAST:
21568 case TREAT:
21569 case TRIM:
21570 case LEFT:
21571 case RIGHT:
21572 case BOTH:
21573 case EMPTY:
21574 case MULTISET:
21575 case SUBMULTISET:
21576 case LEADING:
21577 case TRAILING:
21578 case CHAR_CS:
21579 case NCHAR_CS:
21580 case DBTIMEZONE:
21581 case SESSIONTIMEZONE:
21582 case AUTHENTICATED:
21583 case LINK:
21584 case SHARED:
21585 case DIRECTORY:
21586 case USER:
21587 case IDENTIFIER:
21588 case QUOTED_LITERAL:
21589 case SQLDATA_CLASS:
21590 case CUSTOMDATUM_CLASS:
21591 case ORADATA_CLASS:
21592 case JAVA_INTERFACE_CLASS:
21593 ID();
21594 break;
21595 case STRING_LITERAL:
21596 StringLiteral();
21597 break;
21598 default:
21599 jj_la1[279] = jj_gen;
21600 jj_consume_token(-1);
21601 throw new ParseException();
21602 }
21603 switch (jj_nt.kind) {
21604 case 6:
21605 ;
21606 break;
21607 default:
21608 jj_la1[280] = jj_gen;
21609 break label_67;
21610 }
21611 }
21612 jj_consume_token(7);
21613 break;
21614 case EXCEPTION_INIT:
21615 jj_consume_token(EXCEPTION_INIT);
21616 jj_consume_token(5);
21617 jj_consume_token(IDENTIFIER);
21618 jj_consume_token(6);
21619 switch (jj_nt.kind) {
21620 case 16:
21621 case 17:
21622 switch (jj_nt.kind) {
21623 case 16:
21624 jj_consume_token(16);
21625 break;
21626 case 17:
21627 jj_consume_token(17);
21628 break;
21629 default:
21630 jj_la1[281] = jj_gen;
21631 jj_consume_token(-1);
21632 throw new ParseException();
21633 }
21634 break;
21635 default:
21636 jj_la1[282] = jj_gen;
21637 ;
21638 }
21639 NumericLiteral();
21640 jj_consume_token(7);
21641 break;
21642 case INTERFACE:
21643 jj_consume_token(INTERFACE);
21644 jj_consume_token(5);
21645 jj_consume_token(IDENTIFIER);
21646 jj_consume_token(6);
21647 ID();
21648 switch (jj_nt.kind) {
21649 case 6:
21650 jj_consume_token(6);
21651 NumericLiteral();
21652 break;
21653 default:
21654 jj_la1[283] = jj_gen;
21655 ;
21656 }
21657 jj_consume_token(7);
21658 break;
21659 case REPLACE:
21660 case DEFINER:
21661 case CURRENT_USER:
21662 case LANGUAGE:
21663 case INLINE:
21664 case ADD:
21665 case AGGREGATE:
21666 case ARRAY:
21667 case AT:
21668 case ATTRIBUTE:
21669 case AUTHID:
21670 case BODY:
21671 case BULK:
21672 case BYTE:
21673 case CASCADE:
21674 case CLOSE:
21675 case COALESCE:
21676 case COLLECT:
21677 case COLUMN:
21678 case COMMENT:
21679 case COMMIT:
21680 case CONSTRUCTOR:
21681 case CONTINUE:
21682 case CONVERT:
21683 case CURRENT:
21684 case CURSOR:
21685 case DATA:
21686 case DAY:
21687 case DISABLE:
21688 case EDITIONABLE:
21689 case ELEMENT:
21690 case ENABLE:
21691 case ESCAPE:
21692 case EXCEPT:
21693 case EXCEPTIONS:
21694 case EXIT:
21695 case EXTERNAL:
21696 case EXTENDS:
21697 case EXTRACT:
21698 case FALSE:
21699 case FINAL:
21700 case FORCE:
21701 case FUNCTION:
21702 case GLOBAL:
21703 case HASH:
21704 case HEAP:
21705 case HOUR:
21706 case IMMEDIATE:
21707 case INDICES:
21708 case INDEXTYPE:
21709 case INDICATOR:
21710 case INSTANTIABLE:
21711 case INTERVAL:
21712 case INVALIDATE:
21713 case ISOLATION:
21714 case JAVA:
21715 case LEVEL:
21716 case LIMIT:
21717 case LOOP:
21718 case MAP:
21719 case MAX:
21720 case MEMBER:
21721 case MERGE:
21722 case MIN:
21723 case MINUTE:
21724 case MLSLABEL:
21725 case MODIFY:
21726 case MOD:
21727 case MONTH:
21728 case NATURAL:
21729 case NEW:
21730 case NO:
21731 case NONEDITIONABLE:
21732 case NULLIF:
21733 case OBJECT:
21734 case OID:
21735 case OPAQUE:
21736 case OPEN:
21737 case OPERATOR:
21738 case ORGANIZATION:
21739 case OTHERS:
21740 case OVERRIDING:
21741 case PACKAGE:
21742 case PARTITION:
21743 case PRESERVE:
21744 case PRIVATE:
21745 case PROCEDURE:
21746 case RANGE:
21747 case RAW:
21748 case REAL:
21749 case RECORD:
21750 case REF:
21751 case RELEASE:
21752 case RELIES_ON:
21753 case RENAME:
21754 case RESULT:
21755 case RETURN:
21756 case RETURNING:
21757 case REVERSE:
21758 case ROLLBACK:
21759 case ROW:
21760 case ROWS:
21761 case ROWID:
21762 case ROWNUM:
21763 case SAVE:
21764 case SAVEPOINT:
21765 case SECOND:
21766 case SELF:
21767 case SET:
21768 case SPACE:
21769 case SQL:
21770 case SQLCODE:
21771 case SQLERRM:
21772 case STATIC:
21773 case SUBTYPE:
21774 case SUBSTITUTABLE:
21775 case SUCCESSFUL:
21776 case SYSDATE:
21777 case SYS_REFCURSOR:
21778 case TEMPORARY:
21779 case TIME:
21780 case TIMEZONE_REGION:
21781 case TIMEZONE_ABBR:
21782 case TIMEZONE_MINUTE:
21783 case TIMEZONE_HOUR:
21784 case TRANSACTION:
21785 case TRUE:
21786 case TYPE:
21787 case UNDER:
21788 case USING:
21789 case YES:
21790 case SHOW:
21791 case A:
21792 case DOUBLE:
21793 case DEC:
21794 case PRECISION:
21795 case INT:
21796 case NUMERIC:
21797 case NCHAR:
21798 case NVARCHAR2:
21799 case STRING:
21800 case UROWID:
21801 case VARRAY:
21802 case VARYING:
21803 case BFILE:
21804 case BLOB:
21805 case CLOB:
21806 case NCLOB:
21807 case YEAR:
21808 case LOCAL:
21809 case ZONE:
21810 case CHARACTER:
21811 case AFTER:
21812 case BEFORE:
21813 case OLD:
21814 case PARENT:
21815 case ANALYZE:
21816 case ASSOCIATE:
21817 case AUDIT:
21818 case COMPOUND:
21819 case DATABASE:
21820 case CALL:
21821 case DDL:
21822 case DISASSOCIATE:
21823 case EACH:
21824 case FOLLOWS:
21825 case LOGOFF:
21826 case LOGON:
21827 case NESTED:
21828 case NOAUDIT:
21829 case SCHEMA:
21830 case SERVERERROR:
21831 case SHUTDOWN:
21832 case STARTUP:
21833 case STATEMENT:
21834 case STATISTICS:
21835 case SUSPEND:
21836 case TRUNCATE:
21837 case WRAPPED:
21838 case LIBRARY:
21839 case NAME:
21840 case STRUCT:
21841 case CONTEXT:
21842 case PARAMETERS:
21843 case LENGTH:
21844 case TDO:
21845 case MAXLEN:
21846 case CHARSETID:
21847 case CHARSETFORM:
21848 case ACCEPT:
21849 case ACCESSIBLE:
21850 case COPY:
21851 case DEFINE:
21852 case DISCONNECT:
21853 case HOST:
21854 case PRINT:
21855 case QUIT:
21856 case REMARK:
21857 case UNDEFINE:
21858 case VARIABLE:
21859 case WHENEVER:
21860 case ATTACH:
21861 case CAST:
21862 case TREAT:
21863 case TRIM:
21864 case LEFT:
21865 case RIGHT:
21866 case BOTH:
21867 case EMPTY:
21868 case MULTISET:
21869 case SUBMULTISET:
21870 case LEADING:
21871 case TRAILING:
21872 case CHAR_CS:
21873 case NCHAR_CS:
21874 case DBTIMEZONE:
21875 case SESSIONTIMEZONE:
21876 case AUTHENTICATED:
21877 case LINK:
21878 case SHARED:
21879 case DIRECTORY:
21880 case USER:
21881 case IDENTIFIER:
21882 case QUOTED_LITERAL:
21883 QualifiedName();
21884 jj_consume_token(5);
21885 ReadPastNextOccurrence(")");
21886 break;
21887 default:
21888 jj_la1[284] = jj_gen;
21889 jj_consume_token(-1);
21890 throw new ParseException();
21891 }
21892 jj_consume_token(4);
21893 jjtree.closeNodeScope(jjtn000, true);
21894 jjtc000 = false;
21895 {if (true) return jjtn000 ;}
21896 } catch (Throwable jjte000) {
21897 if (jjtc000) {
21898 jjtree.clearNodeScope(jjtn000);
21899 jjtc000 = false;
21900 } else {
21901 jjtree.popNode();
21902 }
21903 if (jjte000 instanceof RuntimeException) {
21904 {if (true) throw (RuntimeException)jjte000;}
21905 }
21906 if (jjte000 instanceof ParseException) {
21907 {if (true) throw (ParseException)jjte000;}
21908 }
21909 {if (true) throw (Error)jjte000;}
21910 } finally {
21911 if (jjtc000) {
21912 jjtree.closeNodeScope(jjtn000, true);
21913 }
21914 }
21915 throw new Error("Missing return statement in function");
21916 }
21917
21918 final public ASTInlinePragma InlinePragma() throws ParseException {
21919
21920 ASTInlinePragma jjtn000 = new ASTInlinePragma(this, JJTINLINEPRAGMA);
21921 boolean jjtc000 = true;
21922 jjtree.openNodeScope(jjtn000);
21923 try {
21924 jj_consume_token(PRAGMA);
21925 jj_consume_token(INLINE);
21926 jj_consume_token(5);
21927 QualifiedName();
21928 jj_consume_token(6);
21929 StringLiteral();
21930 jj_consume_token(7);
21931 jjtree.closeNodeScope(jjtn000, true);
21932 jjtc000 = false;
21933 {if (true) return jjtn000 ;}
21934 } catch (Throwable jjte000) {
21935 if (jjtc000) {
21936 jjtree.clearNodeScope(jjtn000);
21937 jjtc000 = false;
21938 } else {
21939 jjtree.popNode();
21940 }
21941 if (jjte000 instanceof RuntimeException) {
21942 {if (true) throw (RuntimeException)jjte000;}
21943 }
21944 if (jjte000 instanceof ParseException) {
21945 {if (true) throw (ParseException)jjte000;}
21946 }
21947 {if (true) throw (Error)jjte000;}
21948 } finally {
21949 if (jjtc000) {
21950 jjtree.closeNodeScope(jjtn000, true);
21951 }
21952 }
21953 throw new Error("Missing return statement in function");
21954 }
21955
21956 final public ASTExceptionDeclaration ExceptionDeclaration() throws ParseException {
21957
21958 ASTExceptionDeclaration jjtn000 = new ASTExceptionDeclaration(this, JJTEXCEPTIONDECLARATION);
21959 boolean jjtc000 = true;
21960 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
21961 try {
21962 simpleNode = ID();
21963 jj_consume_token(EXCEPTION);
21964 jj_consume_token(4);
21965 jjtree.closeNodeScope(jjtn000, true);
21966 jjtc000 = false;
21967 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
21968 } catch (Throwable jjte000) {
21969 if (jjtc000) {
21970 jjtree.clearNodeScope(jjtn000);
21971 jjtc000 = false;
21972 } else {
21973 jjtree.popNode();
21974 }
21975 if (jjte000 instanceof RuntimeException) {
21976 {if (true) throw (RuntimeException)jjte000;}
21977 }
21978 if (jjte000 instanceof ParseException) {
21979 {if (true) throw (ParseException)jjte000;}
21980 }
21981 {if (true) throw (Error)jjte000;}
21982 } finally {
21983 if (jjtc000) {
21984 jjtree.closeNodeScope(jjtn000, true);
21985 }
21986 }
21987 throw new Error("Missing return statement in function");
21988 }
21989
21990 final public ASTParallelClause ParallelClause() throws ParseException {
21991
21992 ASTParallelClause jjtn000 = new ASTParallelClause(this, JJTPARALLELCLAUSE);
21993 boolean jjtc000 = true;
21994 jjtree.openNodeScope(jjtn000);
21995 try {
21996 jj_consume_token(5);
21997 jj_consume_token(PARTITION);
21998 ID();
21999 jj_consume_token(BY);
22000 switch (jj_nt.kind) {
22001 case ANY:
22002 jj_consume_token(ANY);
22003 break;
22004 case HASH:
22005 case RANGE:
22006 switch (jj_nt.kind) {
22007 case HASH:
22008 jj_consume_token(HASH);
22009 break;
22010 case RANGE:
22011 jj_consume_token(RANGE);
22012 break;
22013 default:
22014 jj_la1[285] = jj_gen;
22015 jj_consume_token(-1);
22016 throw new ParseException();
22017 }
22018 jj_consume_token(5);
22019 ID();
22020 label_68:
22021 while (true) {
22022 switch (jj_nt.kind) {
22023 case 6:
22024 ;
22025 break;
22026 default:
22027 jj_la1[286] = jj_gen;
22028 break label_68;
22029 }
22030 jj_consume_token(6);
22031 ID();
22032 }
22033 jj_consume_token(7);
22034 break;
22035 default:
22036 jj_la1[287] = jj_gen;
22037 jj_consume_token(-1);
22038 throw new ParseException();
22039 }
22040 jj_consume_token(7);
22041 switch (jj_nt.kind) {
22042 case CLUSTER:
22043 case ORDER:
22044 switch (jj_nt.kind) {
22045 case ORDER:
22046 jj_consume_token(ORDER);
22047 break;
22048 case CLUSTER:
22049 jj_consume_token(CLUSTER);
22050 break;
22051 default:
22052 jj_la1[288] = jj_gen;
22053 jj_consume_token(-1);
22054 throw new ParseException();
22055 }
22056 jj_consume_token(BY);
22057 jj_consume_token(5);
22058 ID();
22059 label_69:
22060 while (true) {
22061 switch (jj_nt.kind) {
22062 case 6:
22063 ;
22064 break;
22065 default:
22066 jj_la1[289] = jj_gen;
22067 break label_69;
22068 }
22069 jj_consume_token(6);
22070 ID();
22071 }
22072 jj_consume_token(7);
22073 break;
22074 default:
22075 jj_la1[290] = jj_gen;
22076 ;
22077 }
22078 jjtree.closeNodeScope(jjtn000, true);
22079 jjtc000 = false;
22080 {if (true) return jjtn000 ;}
22081 } catch (Throwable jjte000) {
22082 if (jjtc000) {
22083 jjtree.clearNodeScope(jjtn000);
22084 jjtc000 = false;
22085 } else {
22086 jjtree.popNode();
22087 }
22088 if (jjte000 instanceof RuntimeException) {
22089 {if (true) throw (RuntimeException)jjte000;}
22090 }
22091 if (jjte000 instanceof ParseException) {
22092 {if (true) throw (ParseException)jjte000;}
22093 }
22094 {if (true) throw (Error)jjte000;}
22095 } finally {
22096 if (jjtc000) {
22097 jjtree.closeNodeScope(jjtn000, true);
22098 }
22099 }
22100 throw new Error("Missing return statement in function");
22101 }
22102
22103 final public ASTAccessibleByClause AccessibleByClause() throws ParseException {
22104
22105 ASTAccessibleByClause jjtn000 = new ASTAccessibleByClause(this, JJTACCESSIBLEBYCLAUSE);
22106 boolean jjtc000 = true;
22107 jjtree.openNodeScope(jjtn000);
22108 try {
22109 jj_consume_token(ACCESSIBLE);
22110 jj_consume_token(BY);
22111 jj_consume_token(5);
22112 switch (jj_nt.kind) {
22113 case FUNCTION:
22114 case PACKAGE:
22115 case PROCEDURE:
22116 case TRIGGER:
22117 case TYPE:
22118 switch (jj_nt.kind) {
22119 case FUNCTION:
22120 jj_consume_token(FUNCTION);
22121 break;
22122 case PROCEDURE:
22123 jj_consume_token(PROCEDURE);
22124 break;
22125 case PACKAGE:
22126 jj_consume_token(PACKAGE);
22127 break;
22128 case TRIGGER:
22129 jj_consume_token(TRIGGER);
22130 break;
22131 case TYPE:
22132 jj_consume_token(TYPE);
22133 break;
22134 default:
22135 jj_la1[291] = jj_gen;
22136 jj_consume_token(-1);
22137 throw new ParseException();
22138 }
22139 break;
22140 default:
22141 jj_la1[292] = jj_gen;
22142 ;
22143 }
22144 QualifiedName();
22145 label_70:
22146 while (true) {
22147 switch (jj_nt.kind) {
22148 case 6:
22149 ;
22150 break;
22151 default:
22152 jj_la1[293] = jj_gen;
22153 break label_70;
22154 }
22155 jj_consume_token(6);
22156 switch (jj_nt.kind) {
22157 case FUNCTION:
22158 case PACKAGE:
22159 case PROCEDURE:
22160 case TRIGGER:
22161 case TYPE:
22162 switch (jj_nt.kind) {
22163 case FUNCTION:
22164 jj_consume_token(FUNCTION);
22165 break;
22166 case PROCEDURE:
22167 jj_consume_token(PROCEDURE);
22168 break;
22169 case PACKAGE:
22170 jj_consume_token(PACKAGE);
22171 break;
22172 case TRIGGER:
22173 jj_consume_token(TRIGGER);
22174 break;
22175 case TYPE:
22176 jj_consume_token(TYPE);
22177 break;
22178 default:
22179 jj_la1[294] = jj_gen;
22180 jj_consume_token(-1);
22181 throw new ParseException();
22182 }
22183 break;
22184 default:
22185 jj_la1[295] = jj_gen;
22186 ;
22187 }
22188 QualifiedName();
22189 }
22190 jj_consume_token(7);
22191 jjtree.closeNodeScope(jjtn000, true);
22192 jjtc000 = false;
22193 {if (true) return jjtn000 ;}
22194 } catch (Throwable jjte000) {
22195 if (jjtc000) {
22196 jjtree.clearNodeScope(jjtn000);
22197 jjtc000 = false;
22198 } else {
22199 jjtree.popNode();
22200 }
22201 if (jjte000 instanceof RuntimeException) {
22202 {if (true) throw (RuntimeException)jjte000;}
22203 }
22204 if (jjte000 instanceof ParseException) {
22205 {if (true) throw (ParseException)jjte000;}
22206 }
22207 {if (true) throw (Error)jjte000;}
22208 } finally {
22209 if (jjtc000) {
22210 jjtree.closeNodeScope(jjtn000, true);
22211 }
22212 }
22213 throw new Error("Missing return statement in function");
22214 }
22215
22216
22217
22218
22219
22220
22221
22222
22223 final public ASTTable Table() throws ParseException {
22224
22225 ASTTable jjtn000 = new ASTTable(this, JJTTABLE);
22226 boolean jjtc000 = true;
22227 jjtree.openNodeScope(jjtn000);
22228 try {
22229 jj_consume_token(CREATE);
22230 switch (jj_nt.kind) {
22231 case GLOBAL:
22232 jj_consume_token(GLOBAL);
22233 jj_consume_token(TEMPORARY);
22234 break;
22235 default:
22236 jj_la1[296] = jj_gen;
22237 ;
22238 }
22239 jj_consume_token(TABLE);
22240 ObjectNameDeclaration();
22241 jj_consume_token(5);
22242 TableColumn();
22243 label_71:
22244 while (true) {
22245 switch (jj_nt.kind) {
22246 case 6:
22247 ;
22248 break;
22249 default:
22250 jj_la1[297] = jj_gen;
22251 break label_71;
22252 }
22253 jj_consume_token(6);
22254 TableColumn();
22255 }
22256 jj_consume_token(7);
22257 if (jj_2_59(2)) {
22258 jj_consume_token(ON);
22259 jj_consume_token(COMMIT);
22260 switch (jj_nt.kind) {
22261 case DELETE:
22262 jj_consume_token(DELETE);
22263 break;
22264 case PRESERVE:
22265 jj_consume_token(PRESERVE);
22266 break;
22267 default:
22268 jj_la1[298] = jj_gen;
22269 jj_consume_token(-1);
22270 throw new ParseException();
22271 }
22272 jj_consume_token(ROWS);
22273 } else {
22274 ;
22275 }
22276 switch (jj_nt.kind) {
22277 case 4:
22278 jj_consume_token(4);
22279 break;
22280 default:
22281 jj_la1[299] = jj_gen;
22282 ;
22283 }
22284 jjtree.closeNodeScope(jjtn000, true);
22285 jjtc000 = false;
22286 {if (true) return jjtn000 ;}
22287 } catch (Throwable jjte000) {
22288 if (jjtc000) {
22289 jjtree.clearNodeScope(jjtn000);
22290 jjtc000 = false;
22291 } else {
22292 jjtree.popNode();
22293 }
22294 if (jjte000 instanceof RuntimeException) {
22295 {if (true) throw (RuntimeException)jjte000;}
22296 }
22297 if (jjte000 instanceof ParseException) {
22298 {if (true) throw (ParseException)jjte000;}
22299 }
22300 {if (true) throw (Error)jjte000;}
22301 } finally {
22302 if (jjtc000) {
22303 jjtree.closeNodeScope(jjtn000, true);
22304 }
22305 }
22306 throw new Error("Missing return statement in function");
22307 }
22308
22309 final public ASTTableColumn TableColumn() throws ParseException {
22310
22311 ASTTableColumn jjtn000 = new ASTTableColumn(this, JJTTABLECOLUMN);
22312 boolean jjtc000 = true;
22313 jjtree.openNodeScope(jjtn000);
22314 try {
22315 ID();
22316 Datatype();
22317 switch (jj_nt.kind) {
22318 case _DEFAULT:
22319 jj_consume_token(_DEFAULT);
22320 Expression();
22321 break;
22322 default:
22323 jj_la1[300] = jj_gen;
22324 ;
22325 }
22326 switch (jj_nt.kind) {
22327 case NOT:
22328 case NULL:
22329 switch (jj_nt.kind) {
22330 case NOT:
22331 jj_consume_token(NOT);
22332 break;
22333 default:
22334 jj_la1[301] = jj_gen;
22335 ;
22336 }
22337 jj_consume_token(NULL);
22338 break;
22339 default:
22340 jj_la1[302] = jj_gen;
22341 ;
22342 }
22343 jjtree.closeNodeScope(jjtn000, true);
22344 jjtc000 = false;
22345 {if (true) return jjtn000 ;}
22346 } catch (Throwable jjte000) {
22347 if (jjtc000) {
22348 jjtree.clearNodeScope(jjtn000);
22349 jjtc000 = false;
22350 } else {
22351 jjtree.popNode();
22352 }
22353 if (jjte000 instanceof RuntimeException) {
22354 {if (true) throw (RuntimeException)jjte000;}
22355 }
22356 if (jjte000 instanceof ParseException) {
22357 {if (true) throw (ParseException)jjte000;}
22358 }
22359 {if (true) throw (Error)jjte000;}
22360 } finally {
22361 if (jjtc000) {
22362 jjtree.closeNodeScope(jjtn000, true);
22363 }
22364 }
22365 throw new Error("Missing return statement in function");
22366 }
22367
22368 final public ASTView View() throws ParseException {
22369
22370 ASTView jjtn000 = new ASTView(this, JJTVIEW);
22371 boolean jjtc000 = true;
22372 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22373 try {
22374 jj_consume_token(CREATE);
22375 switch (jj_nt.kind) {
22376 case OR:
22377 jj_consume_token(OR);
22378 jj_consume_token(REPLACE);
22379 break;
22380 default:
22381 jj_la1[303] = jj_gen;
22382 ;
22383 }
22384 switch (jj_nt.kind) {
22385 case FORCE:
22386 case NO:
22387 switch (jj_nt.kind) {
22388 case NO:
22389 jj_consume_token(NO);
22390 break;
22391 default:
22392 jj_la1[304] = jj_gen;
22393 ;
22394 }
22395 jj_consume_token(FORCE);
22396 break;
22397 default:
22398 jj_la1[305] = jj_gen;
22399 ;
22400 }
22401 jj_consume_token(VIEW);
22402 simpleNode = ObjectNameDeclaration();
22403 switch (jj_nt.kind) {
22404 case 5:
22405 jj_consume_token(5);
22406 ViewColumn();
22407 label_72:
22408 while (true) {
22409 switch (jj_nt.kind) {
22410 case 6:
22411 ;
22412 break;
22413 default:
22414 jj_la1[306] = jj_gen;
22415 break label_72;
22416 }
22417 jj_consume_token(6);
22418 ViewColumn();
22419 }
22420 jj_consume_token(7);
22421 break;
22422 default:
22423 jj_la1[307] = jj_gen;
22424 ;
22425 }
22426 jj_consume_token(AS);
22427 Statement();
22428 switch (jj_nt.kind) {
22429 case 4:
22430 jj_consume_token(4);
22431 break;
22432 case 1:
22433 jj_consume_token(1);
22434 break;
22435 default:
22436 jj_la1[308] = jj_gen;
22437 jj_consume_token(-1);
22438 throw new ParseException();
22439 }
22440 jjtree.closeNodeScope(jjtn000, true);
22441 jjtc000 = false;
22442 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
22443 } catch (Throwable jjte000) {
22444 if (jjtc000) {
22445 jjtree.clearNodeScope(jjtn000);
22446 jjtc000 = false;
22447 } else {
22448 jjtree.popNode();
22449 }
22450 if (jjte000 instanceof RuntimeException) {
22451 {if (true) throw (RuntimeException)jjte000;}
22452 }
22453 if (jjte000 instanceof ParseException) {
22454 {if (true) throw (ParseException)jjte000;}
22455 }
22456 {if (true) throw (Error)jjte000;}
22457 } finally {
22458 if (jjtc000) {
22459 jjtree.closeNodeScope(jjtn000, true);
22460 }
22461 }
22462 throw new Error("Missing return statement in function");
22463 }
22464
22465 final public ASTSynonym Synonym() throws ParseException {
22466
22467 ASTSynonym jjtn000 = new ASTSynonym(this, JJTSYNONYM);
22468 boolean jjtc000 = true;
22469 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22470 try {
22471 jj_consume_token(CREATE);
22472 switch (jj_nt.kind) {
22473 case OR:
22474 jj_consume_token(OR);
22475 jj_consume_token(REPLACE);
22476 break;
22477 default:
22478 jj_la1[309] = jj_gen;
22479 ;
22480 }
22481 switch (jj_nt.kind) {
22482 case PUBLIC:
22483 jj_consume_token(PUBLIC);
22484 break;
22485 default:
22486 jj_la1[310] = jj_gen;
22487 ;
22488 }
22489 jj_consume_token(SYNONYM);
22490 simpleNode = ObjectNameDeclaration();
22491 jj_consume_token(FOR);
22492 ObjectNameDeclaration();
22493 switch (jj_nt.kind) {
22494 case 4:
22495 jj_consume_token(4);
22496 break;
22497 case 1:
22498 jj_consume_token(1);
22499 break;
22500 default:
22501 jj_la1[311] = jj_gen;
22502 jj_consume_token(-1);
22503 throw new ParseException();
22504 }
22505 jjtree.closeNodeScope(jjtn000, true);
22506 jjtc000 = false;
22507 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
22508 } catch (Throwable jjte000) {
22509 if (jjtc000) {
22510 jjtree.clearNodeScope(jjtn000);
22511 jjtc000 = false;
22512 } else {
22513 jjtree.popNode();
22514 }
22515 if (jjte000 instanceof RuntimeException) {
22516 {if (true) throw (RuntimeException)jjte000;}
22517 }
22518 if (jjte000 instanceof ParseException) {
22519 {if (true) throw (ParseException)jjte000;}
22520 }
22521 {if (true) throw (Error)jjte000;}
22522 } finally {
22523 if (jjtc000) {
22524 jjtree.closeNodeScope(jjtn000, true);
22525 }
22526 }
22527 throw new Error("Missing return statement in function");
22528 }
22529
22530 final public ASTDirectory Directory() throws ParseException {
22531
22532 ASTDirectory jjtn000 = new ASTDirectory(this, JJTDIRECTORY);
22533 boolean jjtc000 = true;
22534 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22535 try {
22536 jj_consume_token(CREATE);
22537 switch (jj_nt.kind) {
22538 case OR:
22539 jj_consume_token(OR);
22540 jj_consume_token(REPLACE);
22541 break;
22542 default:
22543 jj_la1[312] = jj_gen;
22544 ;
22545 }
22546 jj_consume_token(DIRECTORY);
22547 simpleNode = ObjectNameDeclaration();
22548 jj_consume_token(AS);
22549 StringLiteral();
22550 switch (jj_nt.kind) {
22551 case 4:
22552 jj_consume_token(4);
22553 break;
22554 case 1:
22555 jj_consume_token(1);
22556 break;
22557 default:
22558 jj_la1[313] = jj_gen;
22559 jj_consume_token(-1);
22560 throw new ParseException();
22561 }
22562 jjtree.closeNodeScope(jjtn000, true);
22563 jjtc000 = false;
22564 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
22565 } catch (Throwable jjte000) {
22566 if (jjtc000) {
22567 jjtree.clearNodeScope(jjtn000);
22568 jjtc000 = false;
22569 } else {
22570 jjtree.popNode();
22571 }
22572 if (jjte000 instanceof RuntimeException) {
22573 {if (true) throw (RuntimeException)jjte000;}
22574 }
22575 if (jjte000 instanceof ParseException) {
22576 {if (true) throw (ParseException)jjte000;}
22577 }
22578 {if (true) throw (Error)jjte000;}
22579 } finally {
22580 if (jjtc000) {
22581 jjtree.closeNodeScope(jjtn000, true);
22582 }
22583 }
22584 throw new Error("Missing return statement in function");
22585 }
22586
22587 final public ASTDatabaseLink DatabaseLink() throws ParseException {
22588
22589 ASTDatabaseLink jjtn000 = new ASTDatabaseLink(this, JJTDATABASELINK);
22590 boolean jjtc000 = true;
22591 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22592 try {
22593 jj_consume_token(CREATE);
22594 switch (jj_nt.kind) {
22595 case SHARED:
22596 jj_consume_token(SHARED);
22597 break;
22598 default:
22599 jj_la1[314] = jj_gen;
22600 ;
22601 }
22602 switch (jj_nt.kind) {
22603 case PUBLIC:
22604 jj_consume_token(PUBLIC);
22605 break;
22606 default:
22607 jj_la1[315] = jj_gen;
22608 ;
22609 }
22610 jj_consume_token(DATABASE);
22611 jj_consume_token(LINK);
22612 simpleNode = ObjectNameDeclaration();
22613 switch (jj_nt.kind) {
22614 case CONNECT:
22615 jj_consume_token(CONNECT);
22616 jj_consume_token(TO);
22617 switch (jj_nt.kind) {
22618 case CURRENT_USER:
22619 jj_consume_token(CURRENT_USER);
22620 break;
22621 case REPLACE:
22622 case DEFINER:
22623 case LANGUAGE:
22624 case INLINE:
22625 case ADD:
22626 case AGGREGATE:
22627 case ARRAY:
22628 case AT:
22629 case ATTRIBUTE:
22630 case AUTHID:
22631 case BODY:
22632 case BULK:
22633 case BYTE:
22634 case CASCADE:
22635 case CLOSE:
22636 case COALESCE:
22637 case COLLECT:
22638 case COLUMN:
22639 case COMMENT:
22640 case COMMIT:
22641 case CONSTRUCTOR:
22642 case CONTINUE:
22643 case CONVERT:
22644 case CURRENT:
22645 case CURSOR:
22646 case DATA:
22647 case DAY:
22648 case DISABLE:
22649 case EDITIONABLE:
22650 case ELEMENT:
22651 case ENABLE:
22652 case ESCAPE:
22653 case EXCEPT:
22654 case EXCEPTIONS:
22655 case EXIT:
22656 case EXTERNAL:
22657 case EXTENDS:
22658 case EXTRACT:
22659 case FALSE:
22660 case FINAL:
22661 case FORCE:
22662 case FUNCTION:
22663 case GLOBAL:
22664 case HASH:
22665 case HEAP:
22666 case HOUR:
22667 case IMMEDIATE:
22668 case INDICES:
22669 case INDEXTYPE:
22670 case INDICATOR:
22671 case INSTANTIABLE:
22672 case INTERVAL:
22673 case INVALIDATE:
22674 case ISOLATION:
22675 case JAVA:
22676 case LEVEL:
22677 case LIMIT:
22678 case LOOP:
22679 case MAP:
22680 case MAX:
22681 case MEMBER:
22682 case MERGE:
22683 case MIN:
22684 case MINUTE:
22685 case MLSLABEL:
22686 case MODIFY:
22687 case MOD:
22688 case MONTH:
22689 case NATURAL:
22690 case NEW:
22691 case NO:
22692 case NONEDITIONABLE:
22693 case NULLIF:
22694 case OBJECT:
22695 case OID:
22696 case OPAQUE:
22697 case OPEN:
22698 case OPERATOR:
22699 case ORGANIZATION:
22700 case OTHERS:
22701 case OVERRIDING:
22702 case PACKAGE:
22703 case PARTITION:
22704 case PRESERVE:
22705 case PRIVATE:
22706 case PROCEDURE:
22707 case RANGE:
22708 case RAW:
22709 case REAL:
22710 case RECORD:
22711 case REF:
22712 case RELEASE:
22713 case RELIES_ON:
22714 case RENAME:
22715 case RESULT:
22716 case RETURN:
22717 case RETURNING:
22718 case REVERSE:
22719 case ROLLBACK:
22720 case ROW:
22721 case ROWS:
22722 case ROWID:
22723 case ROWNUM:
22724 case SAVE:
22725 case SAVEPOINT:
22726 case SECOND:
22727 case SELF:
22728 case SET:
22729 case SPACE:
22730 case SQL:
22731 case SQLCODE:
22732 case SQLERRM:
22733 case STATIC:
22734 case SUBTYPE:
22735 case SUBSTITUTABLE:
22736 case SUCCESSFUL:
22737 case SYSDATE:
22738 case SYS_REFCURSOR:
22739 case TEMPORARY:
22740 case TIME:
22741 case TIMESTAMP:
22742 case TIMEZONE_REGION:
22743 case TIMEZONE_ABBR:
22744 case TIMEZONE_MINUTE:
22745 case TIMEZONE_HOUR:
22746 case TRANSACTION:
22747 case TRUE:
22748 case TYPE:
22749 case UNDER:
22750 case USING:
22751 case YES:
22752 case SHOW:
22753 case A:
22754 case DOUBLE:
22755 case DEC:
22756 case PRECISION:
22757 case INT:
22758 case NUMERIC:
22759 case NCHAR:
22760 case NVARCHAR2:
22761 case STRING:
22762 case UROWID:
22763 case VARRAY:
22764 case VARYING:
22765 case BFILE:
22766 case BLOB:
22767 case CLOB:
22768 case NCLOB:
22769 case YEAR:
22770 case LOCAL:
22771 case ZONE:
22772 case CHARACTER:
22773 case AFTER:
22774 case BEFORE:
22775 case OLD:
22776 case PARENT:
22777 case ANALYZE:
22778 case ASSOCIATE:
22779 case AUDIT:
22780 case COMPOUND:
22781 case DATABASE:
22782 case CALL:
22783 case DDL:
22784 case DISASSOCIATE:
22785 case EACH:
22786 case FOLLOWS:
22787 case LOGOFF:
22788 case LOGON:
22789 case NESTED:
22790 case NOAUDIT:
22791 case SCHEMA:
22792 case SERVERERROR:
22793 case SHUTDOWN:
22794 case STARTUP:
22795 case STATEMENT:
22796 case STATISTICS:
22797 case SUSPEND:
22798 case TRUNCATE:
22799 case WRAPPED:
22800 case LIBRARY:
22801 case NAME:
22802 case STRUCT:
22803 case CONTEXT:
22804 case PARAMETERS:
22805 case LENGTH:
22806 case TDO:
22807 case MAXLEN:
22808 case CHARSETID:
22809 case CHARSETFORM:
22810 case ACCEPT:
22811 case ACCESSIBLE:
22812 case COPY:
22813 case DEFINE:
22814 case DISCONNECT:
22815 case HOST:
22816 case PRINT:
22817 case QUIT:
22818 case REMARK:
22819 case UNDEFINE:
22820 case VARIABLE:
22821 case WHENEVER:
22822 case ATTACH:
22823 case CAST:
22824 case TREAT:
22825 case TRIM:
22826 case LEFT:
22827 case RIGHT:
22828 case BOTH:
22829 case EMPTY:
22830 case MULTISET:
22831 case SUBMULTISET:
22832 case LEADING:
22833 case TRAILING:
22834 case CHAR_CS:
22835 case NCHAR_CS:
22836 case DBTIMEZONE:
22837 case SESSIONTIMEZONE:
22838 case AUTHENTICATED:
22839 case LINK:
22840 case SHARED:
22841 case DIRECTORY:
22842 case USER:
22843 case IDENTIFIER:
22844 case QUOTED_LITERAL:
22845 UnqualifiedID();
22846 jj_consume_token(IDENTIFIED);
22847 jj_consume_token(BY);
22848 UnqualifiedID();
22849 jj_consume_token(AUTHENTICATED);
22850 jj_consume_token(BY);
22851 UnqualifiedID();
22852 jj_consume_token(IDENTIFIED);
22853 jj_consume_token(BY);
22854 UnqualifiedID();
22855 break;
22856 default:
22857 jj_la1[316] = jj_gen;
22858 jj_consume_token(-1);
22859 throw new ParseException();
22860 }
22861 break;
22862 case REPLACE:
22863 case DEFINER:
22864 case CURRENT_USER:
22865 case LANGUAGE:
22866 case INLINE:
22867 case ADD:
22868 case AGGREGATE:
22869 case ARRAY:
22870 case AT:
22871 case ATTRIBUTE:
22872 case AUTHID:
22873 case BODY:
22874 case BULK:
22875 case BYTE:
22876 case CASCADE:
22877 case CLOSE:
22878 case COALESCE:
22879 case COLLECT:
22880 case COLUMN:
22881 case COMMENT:
22882 case COMMIT:
22883 case CONSTRUCTOR:
22884 case CONTINUE:
22885 case CONVERT:
22886 case CURRENT:
22887 case CURSOR:
22888 case DATA:
22889 case DAY:
22890 case DISABLE:
22891 case EDITIONABLE:
22892 case ELEMENT:
22893 case ENABLE:
22894 case ESCAPE:
22895 case EXCEPT:
22896 case EXCEPTIONS:
22897 case EXIT:
22898 case EXTERNAL:
22899 case EXTENDS:
22900 case EXTRACT:
22901 case FALSE:
22902 case FINAL:
22903 case FORCE:
22904 case FUNCTION:
22905 case GLOBAL:
22906 case HASH:
22907 case HEAP:
22908 case HOUR:
22909 case IMMEDIATE:
22910 case INDICES:
22911 case INDEXTYPE:
22912 case INDICATOR:
22913 case INSTANTIABLE:
22914 case INTERVAL:
22915 case INVALIDATE:
22916 case ISOLATION:
22917 case JAVA:
22918 case LEVEL:
22919 case LIMIT:
22920 case LOOP:
22921 case MAP:
22922 case MAX:
22923 case MEMBER:
22924 case MERGE:
22925 case MIN:
22926 case MINUTE:
22927 case MLSLABEL:
22928 case MODIFY:
22929 case MOD:
22930 case MONTH:
22931 case NATURAL:
22932 case NEW:
22933 case NO:
22934 case NONEDITIONABLE:
22935 case NULLIF:
22936 case OBJECT:
22937 case OID:
22938 case OPAQUE:
22939 case OPEN:
22940 case OPERATOR:
22941 case ORGANIZATION:
22942 case OTHERS:
22943 case OVERRIDING:
22944 case PACKAGE:
22945 case PARTITION:
22946 case PRESERVE:
22947 case PRIVATE:
22948 case PROCEDURE:
22949 case RANGE:
22950 case RAW:
22951 case REAL:
22952 case RECORD:
22953 case REF:
22954 case RELEASE:
22955 case RELIES_ON:
22956 case RENAME:
22957 case RESULT:
22958 case RETURN:
22959 case RETURNING:
22960 case REVERSE:
22961 case ROLLBACK:
22962 case ROW:
22963 case ROWS:
22964 case ROWID:
22965 case ROWNUM:
22966 case SAVE:
22967 case SAVEPOINT:
22968 case SECOND:
22969 case SELF:
22970 case SET:
22971 case SPACE:
22972 case SQL:
22973 case SQLCODE:
22974 case SQLERRM:
22975 case STATIC:
22976 case SUBTYPE:
22977 case SUBSTITUTABLE:
22978 case SUCCESSFUL:
22979 case SYSDATE:
22980 case SYS_REFCURSOR:
22981 case TEMPORARY:
22982 case TIME:
22983 case TIMESTAMP:
22984 case TIMEZONE_REGION:
22985 case TIMEZONE_ABBR:
22986 case TIMEZONE_MINUTE:
22987 case TIMEZONE_HOUR:
22988 case TRANSACTION:
22989 case TRUE:
22990 case TYPE:
22991 case UNDER:
22992 case USING:
22993 case YES:
22994 case SHOW:
22995 case A:
22996 case DOUBLE:
22997 case DEC:
22998 case PRECISION:
22999 case INT:
23000 case NUMERIC:
23001 case NCHAR:
23002 case NVARCHAR2:
23003 case STRING:
23004 case UROWID:
23005 case VARRAY:
23006 case VARYING:
23007 case BFILE:
23008 case BLOB:
23009 case CLOB:
23010 case NCLOB:
23011 case YEAR:
23012 case LOCAL:
23013 case ZONE:
23014 case CHARACTER:
23015 case AFTER:
23016 case BEFORE:
23017 case OLD:
23018 case PARENT:
23019 case ANALYZE:
23020 case ASSOCIATE:
23021 case AUDIT:
23022 case COMPOUND:
23023 case DATABASE:
23024 case CALL:
23025 case DDL:
23026 case DISASSOCIATE:
23027 case EACH:
23028 case FOLLOWS:
23029 case LOGOFF:
23030 case LOGON:
23031 case NESTED:
23032 case NOAUDIT:
23033 case SCHEMA:
23034 case SERVERERROR:
23035 case SHUTDOWN:
23036 case STARTUP:
23037 case STATEMENT:
23038 case STATISTICS:
23039 case SUSPEND:
23040 case TRUNCATE:
23041 case WRAPPED:
23042 case LIBRARY:
23043 case NAME:
23044 case STRUCT:
23045 case CONTEXT:
23046 case PARAMETERS:
23047 case LENGTH:
23048 case TDO:
23049 case MAXLEN:
23050 case CHARSETID:
23051 case CHARSETFORM:
23052 case ACCEPT:
23053 case ACCESSIBLE:
23054 case COPY:
23055 case DEFINE:
23056 case DISCONNECT:
23057 case HOST:
23058 case PRINT:
23059 case QUIT:
23060 case REMARK:
23061 case UNDEFINE:
23062 case VARIABLE:
23063 case WHENEVER:
23064 case ATTACH:
23065 case CAST:
23066 case TREAT:
23067 case TRIM:
23068 case LEFT:
23069 case RIGHT:
23070 case BOTH:
23071 case EMPTY:
23072 case MULTISET:
23073 case SUBMULTISET:
23074 case LEADING:
23075 case TRAILING:
23076 case CHAR_CS:
23077 case NCHAR_CS:
23078 case DBTIMEZONE:
23079 case SESSIONTIMEZONE:
23080 case AUTHENTICATED:
23081 case LINK:
23082 case SHARED:
23083 case DIRECTORY:
23084 case USER:
23085 case IDENTIFIER:
23086 case QUOTED_LITERAL:
23087 UnqualifiedID();
23088 jj_consume_token(IDENTIFIED);
23089 jj_consume_token(BY);
23090 UnqualifiedID();
23091 break;
23092 default:
23093 jj_la1[317] = jj_gen;
23094 jj_consume_token(-1);
23095 throw new ParseException();
23096 }
23097 switch (jj_nt.kind) {
23098 case USING:
23099 jj_consume_token(USING);
23100 StringLiteral();
23101 break;
23102 default:
23103 jj_la1[318] = jj_gen;
23104 ;
23105 }
23106 switch (jj_nt.kind) {
23107 case 4:
23108 jj_consume_token(4);
23109 break;
23110 case 1:
23111 jj_consume_token(1);
23112 break;
23113 default:
23114 jj_la1[319] = jj_gen;
23115 jj_consume_token(-1);
23116 throw new ParseException();
23117 }
23118 jjtree.closeNodeScope(jjtn000, true);
23119 jjtc000 = false;
23120 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
23121 } catch (Throwable jjte000) {
23122 if (jjtc000) {
23123 jjtree.clearNodeScope(jjtn000);
23124 jjtc000 = false;
23125 } else {
23126 jjtree.popNode();
23127 }
23128 if (jjte000 instanceof RuntimeException) {
23129 {if (true) throw (RuntimeException)jjte000;}
23130 }
23131 if (jjte000 instanceof ParseException) {
23132 {if (true) throw (ParseException)jjte000;}
23133 }
23134 {if (true) throw (Error)jjte000;}
23135 } finally {
23136 if (jjtc000) {
23137 jjtree.closeNodeScope(jjtn000, true);
23138 }
23139 }
23140 throw new Error("Missing return statement in function");
23141 }
23142
23143 final public ASTViewColumn ViewColumn() throws ParseException {
23144
23145 ASTViewColumn jjtn000 = new ASTViewColumn(this, JJTVIEWCOLUMN);
23146 boolean jjtc000 = true;
23147 jjtree.openNodeScope(jjtn000);
23148 try {
23149 ID();
23150 jjtree.closeNodeScope(jjtn000, true);
23151 jjtc000 = false;
23152 {if (true) return jjtn000 ;}
23153 } catch (Throwable jjte000) {
23154 if (jjtc000) {
23155 jjtree.clearNodeScope(jjtn000);
23156 jjtc000 = false;
23157 } else {
23158 jjtree.popNode();
23159 }
23160 if (jjte000 instanceof RuntimeException) {
23161 {if (true) throw (RuntimeException)jjte000;}
23162 }
23163 if (jjte000 instanceof ParseException) {
23164 {if (true) throw (ParseException)jjte000;}
23165 }
23166 {if (true) throw (Error)jjte000;}
23167 } finally {
23168 if (jjtc000) {
23169 jjtree.closeNodeScope(jjtn000, true);
23170 }
23171 }
23172 throw new Error("Missing return statement in function");
23173 }
23174
23175 final public ASTComment Comment() throws ParseException {
23176
23177 ASTComment jjtn000 = new ASTComment(this, JJTCOMMENT);
23178 boolean jjtc000 = true;
23179 jjtree.openNodeScope(jjtn000);
23180 try {
23181 jj_consume_token(COMMENT);
23182 jj_consume_token(ON);
23183 switch (jj_nt.kind) {
23184 case INDEXTYPE:
23185 case OPERATOR:
23186 case TABLE:
23187 switch (jj_nt.kind) {
23188 case TABLE:
23189 jj_consume_token(TABLE);
23190 break;
23191 case OPERATOR:
23192 jj_consume_token(OPERATOR);
23193 break;
23194 case INDEXTYPE:
23195 jj_consume_token(INDEXTYPE);
23196 break;
23197 default:
23198 jj_la1[320] = jj_gen;
23199 jj_consume_token(-1);
23200 throw new ParseException();
23201 }
23202 if (jj_2_60(2)) {
23203 ID();
23204 jj_consume_token(3);
23205 } else {
23206 ;
23207 }
23208 ID();
23209 break;
23210 case COLUMN:
23211 jj_consume_token(COLUMN);
23212 if (jj_2_61(2147483647)) {
23213 ID();
23214 jj_consume_token(3);
23215 } else {
23216 ;
23217 }
23218 ID();
23219 jj_consume_token(3);
23220 ID();
23221 break;
23222 default:
23223 jj_la1[321] = jj_gen;
23224 jj_consume_token(-1);
23225 throw new ParseException();
23226 }
23227 jj_consume_token(IS);
23228 jj_consume_token(STRING_LITERAL);
23229 switch (jj_nt.kind) {
23230 case 4:
23231 jj_consume_token(4);
23232 break;
23233 default:
23234 jj_la1[322] = jj_gen;
23235 ;
23236 }
23237 jjtree.closeNodeScope(jjtn000, true);
23238 jjtc000 = false;
23239 {if (true) return jjtn000 ;}
23240 } catch (Throwable jjte000) {
23241 if (jjtc000) {
23242 jjtree.clearNodeScope(jjtn000);
23243 jjtc000 = false;
23244 } else {
23245 jjtree.popNode();
23246 }
23247 if (jjte000 instanceof RuntimeException) {
23248 {if (true) throw (RuntimeException)jjte000;}
23249 }
23250 if (jjte000 instanceof ParseException) {
23251 {if (true) throw (ParseException)jjte000;}
23252 }
23253 {if (true) throw (Error)jjte000;}
23254 } finally {
23255 if (jjtc000) {
23256 jjtree.closeNodeScope(jjtn000, true);
23257 }
23258 }
23259 throw new Error("Missing return statement in function");
23260 }
23261
23262
23263 final public ASTTypeMethod TypeMethod() throws ParseException {
23264
23265 ASTTypeMethod jjtn000 = new ASTTypeMethod(this, JJTTYPEMETHOD);
23266 boolean jjtc000 = true;
23267 jjtree.openNodeScope(jjtn000);
23268 try {
23269 getToken(1);
23270
23271
23272 label_73:
23273 while (true) {
23274 switch (jj_nt.kind) {
23275 case FINAL:
23276 case INSTANTIABLE:
23277 case NOT:
23278 case OVERRIDING:
23279 ;
23280 break;
23281 default:
23282 jj_la1[323] = jj_gen;
23283 break label_73;
23284 }
23285 switch (jj_nt.kind) {
23286 case NOT:
23287 jj_consume_token(NOT);
23288 break;
23289 default:
23290 jj_la1[324] = jj_gen;
23291 ;
23292 }
23293 switch (jj_nt.kind) {
23294 case OVERRIDING:
23295 jj_consume_token(OVERRIDING);
23296 break;
23297 case INSTANTIABLE:
23298 jj_consume_token(INSTANTIABLE);
23299 break;
23300 case FINAL:
23301 jj_consume_token(FINAL);
23302 break;
23303 default:
23304 jj_la1[325] = jj_gen;
23305 jj_consume_token(-1);
23306 throw new ParseException();
23307 }
23308 }
23309 switch (jj_nt.kind) {
23310 case MAP:
23311 case ORDER:
23312 switch (jj_nt.kind) {
23313 case MAP:
23314 jj_consume_token(MAP);
23315 break;
23316 case ORDER:
23317 jj_consume_token(ORDER);
23318 break;
23319 default:
23320 jj_la1[326] = jj_gen;
23321 jj_consume_token(-1);
23322 throw new ParseException();
23323 }
23324 break;
23325 default:
23326 jj_la1[327] = jj_gen;
23327 ;
23328 }
23329 switch (jj_nt.kind) {
23330 case CONSTRUCTOR:
23331 jj_consume_token(CONSTRUCTOR);
23332 break;
23333 case MEMBER:
23334 jj_consume_token(MEMBER);
23335 break;
23336 case STATIC:
23337 jj_consume_token(STATIC);
23338 break;
23339 default:
23340 jj_la1[328] = jj_gen;
23341 jj_consume_token(-1);
23342 throw new ParseException();
23343 }
23344 MethodDeclarator();
23345 switch (jj_nt.kind) {
23346 case DETERMINISTIC:
23347 jj_consume_token(DETERMINISTIC);
23348 break;
23349 default:
23350 jj_la1[329] = jj_gen;
23351 ;
23352 }
23353 switch (jj_nt.kind) {
23354 case PARALLEL_ENABLE:
23355 jj_consume_token(PARALLEL_ENABLE);
23356 break;
23357 default:
23358 jj_la1[330] = jj_gen;
23359 ;
23360 }
23361 switch (jj_nt.kind) {
23362 case PIPELINED:
23363 jj_consume_token(PIPELINED);
23364 break;
23365 default:
23366 jj_la1[331] = jj_gen;
23367 ;
23368 }
23369 switch (jj_nt.kind) {
23370 case RESULT_CACHE:
23371 jj_consume_token(RESULT_CACHE);
23372 break;
23373 default:
23374 jj_la1[332] = jj_gen;
23375 ;
23376 }
23377 switch (jj_nt.kind) {
23378 case AS:
23379 case IS:
23380 switch (jj_nt.kind) {
23381 case IS:
23382 jj_consume_token(IS);
23383 break;
23384 case AS:
23385 jj_consume_token(AS);
23386 break;
23387 default:
23388 jj_la1[333] = jj_gen;
23389 jj_consume_token(-1);
23390 throw new ParseException();
23391 }
23392 switch (jj_nt.kind) {
23393 case LANGUAGE:
23394 case EXTERNAL:
23395 CallSpecTail();
23396 switch (jj_nt.kind) {
23397 case 4:
23398 jj_consume_token(4);
23399 break;
23400 default:
23401 jj_la1[334] = jj_gen;
23402 ;
23403 }
23404 break;
23405 case REPLACE:
23406 case DEFINER:
23407 case CURRENT_USER:
23408 case SERIALLY_REUSABLE:
23409 case RESTRICT_REFERENCES:
23410 case EXCEPTION_INIT:
23411 case AUTONOMOUS_TRANSACTION:
23412 case INLINE:
23413 case ADD:
23414 case AGGREGATE:
23415 case ALL:
23416 case ALTER:
23417 case AND:
23418 case ANY:
23419 case ARRAY:
23420 case AS:
23421 case ASC:
23422 case AT:
23423 case ATTRIBUTE:
23424 case AUTHID:
23425 case AVG:
23426 case BEGIN:
23427 case BETWEEN:
23428 case BINARY_INTEGER:
23429 case BODY:
23430 case BOOLEAN:
23431 case BULK:
23432 case BY:
23433 case BYTE:
23434 case CASCADE:
23435 case CASE:
23436 case CHAR:
23437 case CHAR_BASE:
23438 case CHECK:
23439 case CLOSE:
23440 case CLUSTER:
23441 case COALESCE:
23442 case COLLECT:
23443 case COLUMN:
23444 case COMMENT:
23445 case COMMIT:
23446 case COMPRESS:
23447 case CONNECT:
23448 case CONSTANT:
23449 case CONSTRUCTOR:
23450 case CONTINUE:
23451 case CONVERT:
23452 case CREATE:
23453 case CURRENT:
23454 case CURRVAL:
23455 case CURSOR:
23456 case DATA:
23457 case DATE:
23458 case DAY:
23459 case DECLARE:
23460 case DECIMAL:
23461 case _DEFAULT:
23462 case DELETE:
23463 case DESC:
23464 case DISABLE:
23465 case DISTINCT:
23466 case DO:
23467 case DROP:
23468 case EDITIONABLE:
23469 case ELEMENT:
23470 case ELSE:
23471 case ELSIF:
23472 case ENABLE:
23473 case ESCAPE:
23474 case EXCEPT:
23475 case EXCEPTION:
23476 case EXCEPTIONS:
23477 case EXCLUSIVE:
23478 case EXECUTE:
23479 case EXISTS:
23480 case EXIT:
23481 case EXTENDS:
23482 case EXTRACT:
23483 case FALSE:
23484 case FETCH:
23485 case FINAL:
23486 case FLOAT:
23487 case FOR:
23488 case FORALL:
23489 case FORCE:
23490 case FROM:
23491 case FUNCTION:
23492 case GLOBAL:
23493 case GOTO:
23494 case GROUP:
23495 case HASH:
23496 case HAVING:
23497 case HEAP:
23498 case HOUR:
23499 case IF:
23500 case IMMEDIATE:
23501 case IN:
23502 case INDEX:
23503 case INDICES:
23504 case INDEXTYPE:
23505 case INDICATOR:
23506 case INSERT:
23507 case INSTANTIABLE:
23508 case INTEGER:
23509 case INTERFACE:
23510 case INTERSECT:
23511 case INTERVAL:
23512 case INTO:
23513 case INVALIDATE:
23514 case IS:
23515 case ISOLATION:
23516 case JAVA:
23517 case LEVEL:
23518 case LIKE:
23519 case LIMIT:
23520 case LIMITED:
23521 case LOCK:
23522 case LONG:
23523 case LOOP:
23524 case MAP:
23525 case MAX:
23526 case MEMBER:
23527 case MERGE:
23528 case MIN:
23529 case MINUS:
23530 case MINUTE:
23531 case MLSLABEL:
23532 case MODIFY:
23533 case MOD:
23534 case MODE:
23535 case MONTH:
23536 case NATURAL:
23537 case NATURALN:
23538 case NEW:
23539 case NEXTVAL:
23540 case NO:
23541 case NOCOPY:
23542 case NONEDITIONABLE:
23543 case NOT:
23544 case NOWAIT:
23545 case NULL:
23546 case NULLIF:
23547 case NUMBER:
23548 case BFILE_BASE:
23549 case BLOB_BASE:
23550 case CLOB_BASE:
23551 case DATE_BASE:
23552 case NUMBER_BASE:
23553 case OBJECT:
23554 case OCIROWID:
23555 case OF:
23556 case OID:
23557 case ON:
23558 case OPAQUE:
23559 case OPEN:
23560 case OPERATOR:
23561 case OPTION:
23562 case OR:
23563 case ORDER:
23564 case ORGANIZATION:
23565 case OTHERS:
23566 case OUT:
23567 case OVERRIDING:
23568 case PACKAGE:
23569 case PARTITION:
23570 case PCTFREE:
23571 case PLS_INTEGER:
23572 case POSITIVE:
23573 case POSITIVEN:
23574 case PRAGMA:
23575 case PRESERVE:
23576 case PRIOR:
23577 case PROMPT:
23578 case PRIVATE:
23579 case PROCEDURE:
23580 case PUBLIC:
23581 case RAISE:
23582 case RANGE:
23583 case RAW:
23584 case REAL:
23585 case RECORD:
23586 case REF:
23587 case RELEASE:
23588 case RELIES_ON:
23589 case RENAME:
23590 case RESULT:
23591 case RETURN:
23592 case RETURNING:
23593 case REVERSE:
23594 case ROLLBACK:
23595 case ROW:
23596 case ROWS:
23597 case ROWID:
23598 case ROWNUM:
23599 case ROWTYPE:
23600 case SAVE:
23601 case SAVEPOINT:
23602 case SECOND:
23603 case SELECT:
23604 case SELF:
23605 case SEPARATE:
23606 case SET:
23607 case SHARE:
23608 case SMALLINT:
23609 case SPACE:
23610 case SQL:
23611 case SQLCODE:
23612 case SQLERRM:
23613 case START:
23614 case STATIC:
23615 case STDDEV:
23616 case SUBTYPE:
23617 case SUBSTITUTABLE:
23618 case SUCCESSFUL:
23619 case SUM:
23620 case SYNONYM:
23621 case SYSDATE:
23622 case SYS_REFCURSOR:
23623 case TABLE:
23624 case TEMPORARY:
23625 case THEN:
23626 case TIME:
23627 case TIMESTAMP:
23628 case TIMEZONE_REGION:
23629 case TIMEZONE_ABBR:
23630 case TIMEZONE_MINUTE:
23631 case TIMEZONE_HOUR:
23632 case TO:
23633 case TRANSACTION:
23634 case TRIGGER:
23635 case TRUE:
23636 case TYPE:
23637 case UI:
23638 case UNDER:
23639 case USING:
23640 case WHILE:
23641 case YES:
23642 case SHOW:
23643 case A:
23644 case UPDATE:
23645 case VARCHAR:
23646 case VARCHAR2:
23647 case DOUBLE:
23648 case DEC:
23649 case PRECISION:
23650 case INT:
23651 case NUMERIC:
23652 case SIGNTYPE:
23653 case NCHAR:
23654 case NVARCHAR2:
23655 case STRING:
23656 case UROWID:
23657 case VARRAY:
23658 case VARYING:
23659 case BFILE:
23660 case BLOB:
23661 case CLOB:
23662 case NCLOB:
23663 case YEAR:
23664 case LOCAL:
23665 case WITH:
23666 case ZONE:
23667 case CHARACTER:
23668 case AFTER:
23669 case BEFORE:
23670 case OLD:
23671 case PARENT:
23672 case CC_IF:
23673 case ANALYZE:
23674 case ASSOCIATE:
23675 case AUDIT:
23676 case COMPOUND:
23677 case DATABASE:
23678 case CALL:
23679 case DDL:
23680 case DISASSOCIATE:
23681 case EACH:
23682 case FOLLOWS:
23683 case LOGOFF:
23684 case LOGON:
23685 case NESTED:
23686 case NOAUDIT:
23687 case SCHEMA:
23688 case SERVERERROR:
23689 case SHUTDOWN:
23690 case STARTUP:
23691 case STATEMENT:
23692 case STATISTICS:
23693 case SUSPEND:
23694 case TRUNCATE:
23695 case WRAPPED:
23696 case LIBRARY:
23697 case NAME:
23698 case STRUCT:
23699 case CONTEXT:
23700 case PARAMETERS:
23701 case LENGTH:
23702 case TDO:
23703 case MAXLEN:
23704 case CHARSETID:
23705 case CHARSETFORM:
23706 case ACCEPT:
23707 case ACCESSIBLE:
23708 case COPY:
23709 case DEFINE:
23710 case DISCONNECT:
23711 case HOST:
23712 case PRINT:
23713 case QUIT:
23714 case REMARK:
23715 case UNDEFINE:
23716 case VARIABLE:
23717 case WHENEVER:
23718 case ATTACH:
23719 case CAST:
23720 case TREAT:
23721 case TRIM:
23722 case LEFT:
23723 case RIGHT:
23724 case BOTH:
23725 case EMPTY:
23726 case MULTISET:
23727 case SUBMULTISET:
23728 case LEADING:
23729 case TRAILING:
23730 case CHAR_CS:
23731 case NCHAR_CS:
23732 case DBTIMEZONE:
23733 case SESSIONTIMEZONE:
23734 case AUTHENTICATED:
23735 case LINK:
23736 case SHARED:
23737 case DIRECTORY:
23738 case USER:
23739 case IDENTIFIER:
23740 case QUOTED_LITERAL:
23741 case SQLDATA_CLASS:
23742 case CUSTOMDATUM_CLASS:
23743 case ORADATA_CLASS:
23744 case JAVA_INTERFACE_CLASS:
23745 DeclarativeSection();
23746 jj_consume_token(BEGIN);
23747 label_74:
23748 while (true) {
23749 switch (jj_nt.kind) {
23750 case 5:
23751 case 16:
23752 case 17:
23753 case 21:
23754 case REPLACE:
23755 case DEFINER:
23756 case CURRENT_USER:
23757 case LANGUAGE:
23758 case INLINE:
23759 case ADD:
23760 case AGGREGATE:
23761 case ARRAY:
23762 case AT:
23763 case ATTRIBUTE:
23764 case AUTHID:
23765 case BEGIN:
23766 case BODY:
23767 case BULK:
23768 case BYTE:
23769 case CASCADE:
23770 case CASE:
23771 case CLOSE:
23772 case COALESCE:
23773 case COLLECT:
23774 case COLUMN:
23775 case COMMENT:
23776 case COMMIT:
23777 case CONSTRUCTOR:
23778 case CONTINUE:
23779 case CONVERT:
23780 case CURRENT:
23781 case CURSOR:
23782 case DATA:
23783 case DATE:
23784 case DAY:
23785 case DECLARE:
23786 case DELETE:
23787 case DISABLE:
23788 case EDITIONABLE:
23789 case ELEMENT:
23790 case ENABLE:
23791 case ESCAPE:
23792 case EXCEPT:
23793 case EXCEPTIONS:
23794 case EXECUTE:
23795 case EXIT:
23796 case EXTERNAL:
23797 case EXTENDS:
23798 case EXTRACT:
23799 case FALSE:
23800 case FETCH:
23801 case FINAL:
23802 case FOR:
23803 case FORALL:
23804 case FORCE:
23805 case FUNCTION:
23806 case GLOBAL:
23807 case GOTO:
23808 case HASH:
23809 case HEAP:
23810 case HOUR:
23811 case IF:
23812 case IMMEDIATE:
23813 case INDICES:
23814 case INDEXTYPE:
23815 case INDICATOR:
23816 case INSERT:
23817 case INSTANTIABLE:
23818 case INTERVAL:
23819 case INVALIDATE:
23820 case ISOLATION:
23821 case JAVA:
23822 case LEVEL:
23823 case LIMIT:
23824 case LOCK:
23825 case LOOP:
23826 case MAP:
23827 case MAX:
23828 case MEMBER:
23829 case MERGE:
23830 case MIN:
23831 case MINUTE:
23832 case MLSLABEL:
23833 case MODIFY:
23834 case MOD:
23835 case MONTH:
23836 case NATURAL:
23837 case NEW:
23838 case NEW_DOT:
23839 case NO:
23840 case NONEDITIONABLE:
23841 case NOT:
23842 case NULL:
23843 case NULLIF:
23844 case OBJECT:
23845 case OID:
23846 case OPAQUE:
23847 case OPEN:
23848 case OPERATOR:
23849 case ORGANIZATION:
23850 case OTHERS:
23851 case OVERRIDING:
23852 case PACKAGE:
23853 case PARTITION:
23854 case PIPE:
23855 case PRAGMA:
23856 case PRESERVE:
23857 case PRIVATE:
23858 case PROCEDURE:
23859 case RAISE:
23860 case RANGE:
23861 case RAW:
23862 case REAL:
23863 case RECORD:
23864 case REF:
23865 case RELEASE:
23866 case RELIES_ON:
23867 case RENAME:
23868 case RESULT:
23869 case RETURN:
23870 case RETURNING:
23871 case REVERSE:
23872 case ROLLBACK:
23873 case ROW:
23874 case ROWS:
23875 case ROWID:
23876 case ROWNUM:
23877 case SAVE:
23878 case SAVEPOINT:
23879 case SECOND:
23880 case SELECT:
23881 case SELF:
23882 case SET:
23883 case SPACE:
23884 case SQL:
23885 case SQLCODE:
23886 case SQLERRM:
23887 case STATIC:
23888 case SUBTYPE:
23889 case SUBSTITUTABLE:
23890 case SUCCESSFUL:
23891 case SYSDATE:
23892 case SYS_REFCURSOR:
23893 case TEMPORARY:
23894 case TIME:
23895 case TIMESTAMP:
23896 case TIMEZONE_REGION:
23897 case TIMEZONE_ABBR:
23898 case TIMEZONE_MINUTE:
23899 case TIMEZONE_HOUR:
23900 case TRANSACTION:
23901 case TRUE:
23902 case TYPE:
23903 case UNDER:
23904 case USING:
23905 case WHILE:
23906 case YES:
23907 case SHOW:
23908 case A:
23909 case UPDATE:
23910 case DOUBLE:
23911 case DEC:
23912 case PRECISION:
23913 case INT:
23914 case NUMERIC:
23915 case NCHAR:
23916 case NVARCHAR2:
23917 case STRING:
23918 case UROWID:
23919 case VARRAY:
23920 case VARYING:
23921 case BFILE:
23922 case BLOB:
23923 case CLOB:
23924 case NCLOB:
23925 case YEAR:
23926 case LOCAL:
23927 case WITH:
23928 case ZONE:
23929 case CHARACTER:
23930 case AFTER:
23931 case BEFORE:
23932 case OLD:
23933 case PARENT:
23934 case CC_IF:
23935 case CC_ERROR:
23936 case ANALYZE:
23937 case ASSOCIATE:
23938 case AUDIT:
23939 case COMPOUND:
23940 case DATABASE:
23941 case CALL:
23942 case DDL:
23943 case DISASSOCIATE:
23944 case EACH:
23945 case FOLLOWS:
23946 case LOGOFF:
23947 case LOGON:
23948 case NESTED:
23949 case NOAUDIT:
23950 case SCHEMA:
23951 case SERVERERROR:
23952 case SHUTDOWN:
23953 case STARTUP:
23954 case STATEMENT:
23955 case STATISTICS:
23956 case SUSPEND:
23957 case TRUNCATE:
23958 case WRAPPED:
23959 case LIBRARY:
23960 case NAME:
23961 case STRUCT:
23962 case CONTEXT:
23963 case PARAMETERS:
23964 case LENGTH:
23965 case TDO:
23966 case MAXLEN:
23967 case CHARSETID:
23968 case CHARSETFORM:
23969 case ACCEPT:
23970 case ACCESSIBLE:
23971 case COPY:
23972 case DEFINE:
23973 case DISCONNECT:
23974 case HOST:
23975 case PRINT:
23976 case QUIT:
23977 case REMARK:
23978 case UNDEFINE:
23979 case VARIABLE:
23980 case WHENEVER:
23981 case ATTACH:
23982 case CAST:
23983 case TREAT:
23984 case TRIM:
23985 case LEFT:
23986 case RIGHT:
23987 case BOTH:
23988 case EMPTY:
23989 case MULTISET:
23990 case SUBMULTISET:
23991 case LEADING:
23992 case TRAILING:
23993 case CHAR_CS:
23994 case NCHAR_CS:
23995 case DBTIMEZONE:
23996 case SESSIONTIMEZONE:
23997 case AUTHENTICATED:
23998 case LINK:
23999 case SHARED:
24000 case DIRECTORY:
24001 case USER:
24002 case IDENTIFIER:
24003 case UNSIGNED_NUMERIC_LITERAL:
24004 case CHARACTER_LITERAL:
24005 case STRING_LITERAL:
24006 case QUOTED_LITERAL:
24007 ;
24008 break;
24009 default:
24010 jj_la1[335] = jj_gen;
24011 break label_74;
24012 }
24013 Statement();
24014 }
24015 switch (jj_nt.kind) {
24016 case EXCEPTION:
24017 ExceptionHandler();
24018 break;
24019 default:
24020 jj_la1[336] = jj_gen;
24021 ;
24022 }
24023 jj_consume_token(END);
24024 switch (jj_nt.kind) {
24025 case REPLACE:
24026 case DEFINER:
24027 case CURRENT_USER:
24028 case SERIALLY_REUSABLE:
24029 case RESTRICT_REFERENCES:
24030 case EXCEPTION_INIT:
24031 case AUTONOMOUS_TRANSACTION:
24032 case LANGUAGE:
24033 case INLINE:
24034 case ADD:
24035 case AGGREGATE:
24036 case ALL:
24037 case ALTER:
24038 case AND:
24039 case ANY:
24040 case ARRAY:
24041 case AS:
24042 case ASC:
24043 case AT:
24044 case ATTRIBUTE:
24045 case AUTHID:
24046 case AVG:
24047 case BETWEEN:
24048 case BINARY_INTEGER:
24049 case BODY:
24050 case BOOLEAN:
24051 case BULK:
24052 case BY:
24053 case BYTE:
24054 case CASCADE:
24055 case CASE:
24056 case CHAR:
24057 case CHAR_BASE:
24058 case CHECK:
24059 case CLOSE:
24060 case CLUSTER:
24061 case COALESCE:
24062 case COLLECT:
24063 case COLUMN:
24064 case COMMENT:
24065 case COMMIT:
24066 case COMPRESS:
24067 case CONNECT:
24068 case CONSTANT:
24069 case CONSTRUCTOR:
24070 case CONTINUE:
24071 case CONVERT:
24072 case CREATE:
24073 case CURRENT:
24074 case CURRVAL:
24075 case CURSOR:
24076 case DATA:
24077 case DATE:
24078 case DAY:
24079 case DECLARE:
24080 case DECIMAL:
24081 case _DEFAULT:
24082 case DELETE:
24083 case DESC:
24084 case DISABLE:
24085 case DISTINCT:
24086 case DO:
24087 case DROP:
24088 case EDITIONABLE:
24089 case ELEMENT:
24090 case ELSE:
24091 case ELSIF:
24092 case ENABLE:
24093 case ESCAPE:
24094 case EXCEPT:
24095 case EXCEPTION:
24096 case EXCEPTIONS:
24097 case EXCLUSIVE:
24098 case EXECUTE:
24099 case EXISTS:
24100 case EXIT:
24101 case EXTERNAL:
24102 case EXTENDS:
24103 case EXTRACT:
24104 case FALSE:
24105 case FETCH:
24106 case FINAL:
24107 case FLOAT:
24108 case FOR:
24109 case FORALL:
24110 case FORCE:
24111 case FROM:
24112 case FUNCTION:
24113 case GLOBAL:
24114 case GOTO:
24115 case GROUP:
24116 case HASH:
24117 case HAVING:
24118 case HEAP:
24119 case HOUR:
24120 case IF:
24121 case IMMEDIATE:
24122 case IN:
24123 case INDEX:
24124 case INDICES:
24125 case INDEXTYPE:
24126 case INDICATOR:
24127 case INSERT:
24128 case INSTANTIABLE:
24129 case INTEGER:
24130 case INTERFACE:
24131 case INTERSECT:
24132 case INTERVAL:
24133 case INTO:
24134 case INVALIDATE:
24135 case IS:
24136 case ISOLATION:
24137 case JAVA:
24138 case LEVEL:
24139 case LIKE:
24140 case LIMIT:
24141 case LIMITED:
24142 case LOCK:
24143 case LONG:
24144 case LOOP:
24145 case MAP:
24146 case MAX:
24147 case MEMBER:
24148 case MERGE:
24149 case MIN:
24150 case MINUS:
24151 case MINUTE:
24152 case MLSLABEL:
24153 case MODIFY:
24154 case MOD:
24155 case MODE:
24156 case MONTH:
24157 case NATURAL:
24158 case NATURALN:
24159 case NEW:
24160 case NEXTVAL:
24161 case NO:
24162 case NOCOPY:
24163 case NONEDITIONABLE:
24164 case NOT:
24165 case NOWAIT:
24166 case NULL:
24167 case NULLIF:
24168 case NUMBER:
24169 case BFILE_BASE:
24170 case BLOB_BASE:
24171 case CLOB_BASE:
24172 case DATE_BASE:
24173 case NUMBER_BASE:
24174 case OBJECT:
24175 case OCIROWID:
24176 case OF:
24177 case OID:
24178 case ON:
24179 case OPAQUE:
24180 case OPEN:
24181 case OPERATOR:
24182 case OPTION:
24183 case OR:
24184 case ORDER:
24185 case ORGANIZATION:
24186 case OTHERS:
24187 case OUT:
24188 case OVERRIDING:
24189 case PACKAGE:
24190 case PARTITION:
24191 case PCTFREE:
24192 case PLS_INTEGER:
24193 case POSITIVE:
24194 case POSITIVEN:
24195 case PRESERVE:
24196 case PRIOR:
24197 case PROMPT:
24198 case PRIVATE:
24199 case PROCEDURE:
24200 case PUBLIC:
24201 case RAISE:
24202 case RANGE:
24203 case RAW:
24204 case REAL:
24205 case RECORD:
24206 case REF:
24207 case RELEASE:
24208 case RELIES_ON:
24209 case RENAME:
24210 case RESULT:
24211 case RETURN:
24212 case RETURNING:
24213 case REVERSE:
24214 case ROLLBACK:
24215 case ROW:
24216 case ROWS:
24217 case ROWID:
24218 case ROWNUM:
24219 case ROWTYPE:
24220 case SAVE:
24221 case SAVEPOINT:
24222 case SECOND:
24223 case SELECT:
24224 case SELF:
24225 case SEPARATE:
24226 case SET:
24227 case SHARE:
24228 case SMALLINT:
24229 case SPACE:
24230 case SQL:
24231 case SQLCODE:
24232 case SQLERRM:
24233 case START:
24234 case STATIC:
24235 case STDDEV:
24236 case SUBTYPE:
24237 case SUBSTITUTABLE:
24238 case SUCCESSFUL:
24239 case SUM:
24240 case SYNONYM:
24241 case SYSDATE:
24242 case SYS_REFCURSOR:
24243 case TABLE:
24244 case TEMPORARY:
24245 case THEN:
24246 case TIME:
24247 case TIMESTAMP:
24248 case TIMEZONE_REGION:
24249 case TIMEZONE_ABBR:
24250 case TIMEZONE_MINUTE:
24251 case TIMEZONE_HOUR:
24252 case TO:
24253 case TRANSACTION:
24254 case TRIGGER:
24255 case TRUE:
24256 case TYPE:
24257 case UI:
24258 case UNDER:
24259 case USING:
24260 case WHILE:
24261 case YES:
24262 case SHOW:
24263 case A:
24264 case UPDATE:
24265 case VARCHAR:
24266 case VARCHAR2:
24267 case DOUBLE:
24268 case DEC:
24269 case PRECISION:
24270 case INT:
24271 case NUMERIC:
24272 case SIGNTYPE:
24273 case NCHAR:
24274 case NVARCHAR2:
24275 case STRING:
24276 case UROWID:
24277 case VARRAY:
24278 case VARYING:
24279 case BFILE:
24280 case BLOB:
24281 case CLOB:
24282 case NCLOB:
24283 case YEAR:
24284 case LOCAL:
24285 case WITH:
24286 case ZONE:
24287 case CHARACTER:
24288 case AFTER:
24289 case BEFORE:
24290 case OLD:
24291 case PARENT:
24292 case ANALYZE:
24293 case ASSOCIATE:
24294 case AUDIT:
24295 case COMPOUND:
24296 case DATABASE:
24297 case CALL:
24298 case DDL:
24299 case DISASSOCIATE:
24300 case EACH:
24301 case FOLLOWS:
24302 case LOGOFF:
24303 case LOGON:
24304 case NESTED:
24305 case NOAUDIT:
24306 case SCHEMA:
24307 case SERVERERROR:
24308 case SHUTDOWN:
24309 case STARTUP:
24310 case STATEMENT:
24311 case STATISTICS:
24312 case SUSPEND:
24313 case TRUNCATE:
24314 case WRAPPED:
24315 case LIBRARY:
24316 case NAME:
24317 case STRUCT:
24318 case CONTEXT:
24319 case PARAMETERS:
24320 case LENGTH:
24321 case TDO:
24322 case MAXLEN:
24323 case CHARSETID:
24324 case CHARSETFORM:
24325 case ACCEPT:
24326 case ACCESSIBLE:
24327 case COPY:
24328 case DEFINE:
24329 case DISCONNECT:
24330 case HOST:
24331 case PRINT:
24332 case QUIT:
24333 case REMARK:
24334 case UNDEFINE:
24335 case VARIABLE:
24336 case WHENEVER:
24337 case ATTACH:
24338 case CAST:
24339 case TREAT:
24340 case TRIM:
24341 case LEFT:
24342 case RIGHT:
24343 case BOTH:
24344 case EMPTY:
24345 case MULTISET:
24346 case SUBMULTISET:
24347 case LEADING:
24348 case TRAILING:
24349 case CHAR_CS:
24350 case NCHAR_CS:
24351 case DBTIMEZONE:
24352 case SESSIONTIMEZONE:
24353 case AUTHENTICATED:
24354 case LINK:
24355 case SHARED:
24356 case DIRECTORY:
24357 case USER:
24358 case IDENTIFIER:
24359 case QUOTED_LITERAL:
24360 case SQLDATA_CLASS:
24361 case CUSTOMDATUM_CLASS:
24362 case ORADATA_CLASS:
24363 case JAVA_INTERFACE_CLASS:
24364 ID();
24365 break;
24366 default:
24367 jj_la1[337] = jj_gen;
24368 ;
24369 }
24370 jj_consume_token(4);
24371 break;
24372 default:
24373 jj_la1[338] = jj_gen;
24374 jj_consume_token(-1);
24375 throw new ParseException();
24376 }
24377 break;
24378 default:
24379 jj_la1[339] = jj_gen;
24380 ;
24381 }
24382 jjtree.closeNodeScope(jjtn000, true);
24383 jjtc000 = false;
24384 {if (true) return jjtn000 ;}
24385 } catch (Throwable jjte000) {
24386 if (jjtc000) {
24387 jjtree.clearNodeScope(jjtn000);
24388 jjtc000 = false;
24389 } else {
24390 jjtree.popNode();
24391 }
24392 if (jjte000 instanceof RuntimeException) {
24393 {if (true) throw (RuntimeException)jjte000;}
24394 }
24395 if (jjte000 instanceof ParseException) {
24396 {if (true) throw (ParseException)jjte000;}
24397 }
24398 {if (true) throw (Error)jjte000;}
24399 } finally {
24400 if (jjtc000) {
24401 jjtree.closeNodeScope(jjtn000, true);
24402 }
24403 }
24404 throw new Error("Missing return statement in function");
24405 }
24406
24407 final public ASTTypeSpecification TypeSpecification() throws ParseException {
24408
24409 ASTTypeSpecification jjtn000 = new ASTTypeSpecification(this, JJTTYPESPECIFICATION);
24410 boolean jjtc000 = true;
24411 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
24412 try {
24413 switch (jj_nt.kind) {
24414 case CREATE:
24415 jj_consume_token(CREATE);
24416 switch (jj_nt.kind) {
24417 case OR:
24418 jj_consume_token(OR);
24419 jj_consume_token(REPLACE);
24420 break;
24421 default:
24422 jj_la1[340] = jj_gen;
24423 ;
24424 }
24425 switch (jj_nt.kind) {
24426 case EDITIONABLE:
24427 case NONEDITIONABLE:
24428 switch (jj_nt.kind) {
24429 case EDITIONABLE:
24430 jj_consume_token(EDITIONABLE);
24431 break;
24432 case NONEDITIONABLE:
24433 jj_consume_token(NONEDITIONABLE);
24434 break;
24435 default:
24436 jj_la1[341] = jj_gen;
24437 jj_consume_token(-1);
24438 throw new ParseException();
24439 }
24440 break;
24441 default:
24442 jj_la1[342] = jj_gen;
24443 ;
24444 }
24445 break;
24446 default:
24447 jj_la1[343] = jj_gen;
24448 ;
24449 }
24450 jj_consume_token(TYPE);
24451 simpleNode = ObjectNameDeclaration();
24452 switch (jj_nt.kind) {
24453 case FORCE:
24454 jj_consume_token(FORCE);
24455 break;
24456 default:
24457 jj_la1[344] = jj_gen;
24458 ;
24459 }
24460 if (jj_2_62(2)) {
24461 jj_consume_token(OID);
24462 jj_consume_token(STRING_LITERAL);
24463 } else {
24464 ;
24465 }
24466 label_75:
24467 while (true) {
24468 if (jj_2_63(2)) {
24469 ;
24470 } else {
24471 break label_75;
24472 }
24473 switch (jj_nt.kind) {
24474 case AUTHID:
24475 jj_consume_token(AUTHID);
24476 switch (jj_nt.kind) {
24477 case CURRENT_USER:
24478 jj_consume_token(CURRENT_USER);
24479 break;
24480 case DEFINER:
24481 jj_consume_token(DEFINER);
24482 break;
24483 default:
24484 jj_la1[345] = jj_gen;
24485 jj_consume_token(-1);
24486 throw new ParseException();
24487 }
24488 break;
24489 case ACCESSIBLE:
24490 AccessibleByClause();
24491 break;
24492 default:
24493 jj_la1[346] = jj_gen;
24494 jj_consume_token(-1);
24495 throw new ParseException();
24496 }
24497 }
24498 switch (jj_nt.kind) {
24499 case AS:
24500 case IS:
24501 case UNDER:
24502 switch (jj_nt.kind) {
24503 case UNDER:
24504 jj_consume_token(UNDER);
24505 ObjectNameDeclaration();
24506 break;
24507 default:
24508 jj_la1[353] = jj_gen;
24509 if (jj_2_64(2)) {
24510 switch (jj_nt.kind) {
24511 case IS:
24512 jj_consume_token(IS);
24513 break;
24514 case AS:
24515 jj_consume_token(AS);
24516 break;
24517 default:
24518 jj_la1[347] = jj_gen;
24519 jj_consume_token(-1);
24520 throw new ParseException();
24521 }
24522 jj_consume_token(OBJECT);
24523 } else if (jj_2_65(2)) {
24524 switch (jj_nt.kind) {
24525 case IS:
24526 jj_consume_token(IS);
24527 break;
24528 case AS:
24529 jj_consume_token(AS);
24530 break;
24531 default:
24532 jj_la1[348] = jj_gen;
24533 jj_consume_token(-1);
24534 throw new ParseException();
24535 }
24536 jj_consume_token(OPAQUE);
24537 jj_consume_token(VARYING);
24538 jj_consume_token(24);
24539 jj_consume_token(USING);
24540 jj_consume_token(LIBRARY);
24541 switch (jj_nt.kind) {
24542 case IDENTIFIER:
24543 jj_consume_token(IDENTIFIER);
24544 break;
24545 case QUOTED_LITERAL:
24546 jj_consume_token(QUOTED_LITERAL);
24547 break;
24548 case STRING_LITERAL:
24549 StringLiteral();
24550 break;
24551 default:
24552 jj_la1[349] = jj_gen;
24553 jj_consume_token(-1);
24554 throw new ParseException();
24555 }
24556 switch (jj_nt.kind) {
24557 case 3:
24558 jj_consume_token(3);
24559 switch (jj_nt.kind) {
24560 case IDENTIFIER:
24561 jj_consume_token(IDENTIFIER);
24562 break;
24563 case QUOTED_LITERAL:
24564 jj_consume_token(QUOTED_LITERAL);
24565 break;
24566 case STRING_LITERAL:
24567 StringLiteral();
24568 break;
24569 default:
24570 jj_la1[350] = jj_gen;
24571 jj_consume_token(-1);
24572 throw new ParseException();
24573 }
24574 break;
24575 default:
24576 jj_la1[351] = jj_gen;
24577 ;
24578 }
24579 } else if (jj_2_66(2)) {
24580 switch (jj_nt.kind) {
24581 case IS:
24582 jj_consume_token(IS);
24583 break;
24584 case AS:
24585 jj_consume_token(AS);
24586 break;
24587 default:
24588 jj_la1[352] = jj_gen;
24589 jj_consume_token(-1);
24590 throw new ParseException();
24591 }
24592 CollectionTypeName();
24593 jj_consume_token(OF);
24594 Datatype();
24595 } else {
24596 jj_consume_token(-1);
24597 throw new ParseException();
24598 }
24599 }
24600 break;
24601 default:
24602 jj_la1[354] = jj_gen;
24603 ;
24604 }
24605 if (jj_2_67(8)) {
24606 jj_consume_token(EXTERNAL);
24607 jj_consume_token(IDENTIFIER);
24608 jj_consume_token(IDENTIFIER);
24609 jj_consume_token(LANGUAGE);
24610 jj_consume_token(JAVA);
24611 jj_consume_token(USING);
24612 jj_consume_token(IDENTIFIER);
24613 } else {
24614 ;
24615 }
24616 switch (jj_nt.kind) {
24617 case WRAPPED:
24618 WrappedObject();
24619 break;
24620 default:
24621 jj_la1[355] = jj_gen;
24622 ;
24623 }
24624 switch (jj_nt.kind) {
24625 case 5:
24626 jj_consume_token(5);
24627 label_76:
24628 while (true) {
24629 switch (jj_nt.kind) {
24630 case REPLACE:
24631 case DEFINER:
24632 case CURRENT_USER:
24633 case SERIALLY_REUSABLE:
24634 case RESTRICT_REFERENCES:
24635 case EXCEPTION_INIT:
24636 case AUTONOMOUS_TRANSACTION:
24637 case LANGUAGE:
24638 case INLINE:
24639 case ADD:
24640 case AGGREGATE:
24641 case ALL:
24642 case ALTER:
24643 case AND:
24644 case ANY:
24645 case ARRAY:
24646 case AS:
24647 case ASC:
24648 case AT:
24649 case ATTRIBUTE:
24650 case AUTHID:
24651 case AVG:
24652 case BETWEEN:
24653 case BINARY_INTEGER:
24654 case BODY:
24655 case BOOLEAN:
24656 case BULK:
24657 case BY:
24658 case BYTE:
24659 case CASCADE:
24660 case CASE:
24661 case CHAR:
24662 case CHAR_BASE:
24663 case CHECK:
24664 case CLOSE:
24665 case CLUSTER:
24666 case COALESCE:
24667 case COLLECT:
24668 case COLUMN:
24669 case COMMENT:
24670 case COMMIT:
24671 case COMPRESS:
24672 case CONNECT:
24673 case CONSTANT:
24674 case CONSTRUCTOR:
24675 case CONTINUE:
24676 case CONVERT:
24677 case CREATE:
24678 case CURRENT:
24679 case CURRVAL:
24680 case CURSOR:
24681 case DATA:
24682 case DATE:
24683 case DAY:
24684 case DECLARE:
24685 case DECIMAL:
24686 case _DEFAULT:
24687 case DELETE:
24688 case DESC:
24689 case DISABLE:
24690 case DISTINCT:
24691 case DO:
24692 case DROP:
24693 case EDITIONABLE:
24694 case ELEMENT:
24695 case ELSE:
24696 case ELSIF:
24697 case ENABLE:
24698 case ESCAPE:
24699 case EXCEPT:
24700 case EXCEPTION:
24701 case EXCEPTIONS:
24702 case EXCLUSIVE:
24703 case EXECUTE:
24704 case EXISTS:
24705 case EXIT:
24706 case EXTERNAL:
24707 case EXTENDS:
24708 case EXTRACT:
24709 case FALSE:
24710 case FETCH:
24711 case FINAL:
24712 case FLOAT:
24713 case FOR:
24714 case FORALL:
24715 case FORCE:
24716 case FROM:
24717 case FUNCTION:
24718 case GLOBAL:
24719 case GOTO:
24720 case GROUP:
24721 case HASH:
24722 case HAVING:
24723 case HEAP:
24724 case HOUR:
24725 case IF:
24726 case IMMEDIATE:
24727 case IN:
24728 case INDEX:
24729 case INDICES:
24730 case INDEXTYPE:
24731 case INDICATOR:
24732 case INSERT:
24733 case INSTANTIABLE:
24734 case INTEGER:
24735 case INTERFACE:
24736 case INTERSECT:
24737 case INTERVAL:
24738 case INTO:
24739 case INVALIDATE:
24740 case IS:
24741 case ISOLATION:
24742 case JAVA:
24743 case LEVEL:
24744 case LIKE:
24745 case LIMIT:
24746 case LIMITED:
24747 case LOCK:
24748 case LONG:
24749 case LOOP:
24750 case MAP:
24751 case MAX:
24752 case MEMBER:
24753 case MERGE:
24754 case MIN:
24755 case MINUS:
24756 case MINUTE:
24757 case MLSLABEL:
24758 case MODIFY:
24759 case MOD:
24760 case MODE:
24761 case MONTH:
24762 case NATURAL:
24763 case NATURALN:
24764 case NEW:
24765 case NEXTVAL:
24766 case NO:
24767 case NOCOPY:
24768 case NONEDITIONABLE:
24769 case NOT:
24770 case NOWAIT:
24771 case NULL:
24772 case NULLIF:
24773 case NUMBER:
24774 case BFILE_BASE:
24775 case BLOB_BASE:
24776 case CLOB_BASE:
24777 case DATE_BASE:
24778 case NUMBER_BASE:
24779 case OBJECT:
24780 case OCIROWID:
24781 case OF:
24782 case OID:
24783 case ON:
24784 case OPAQUE:
24785 case OPEN:
24786 case OPERATOR:
24787 case OPTION:
24788 case OR:
24789 case ORDER:
24790 case ORGANIZATION:
24791 case OTHERS:
24792 case OUT:
24793 case OVERRIDING:
24794 case PACKAGE:
24795 case PARTITION:
24796 case PCTFREE:
24797 case PLS_INTEGER:
24798 case POSITIVE:
24799 case POSITIVEN:
24800 case PRAGMA:
24801 case PRESERVE:
24802 case PRIOR:
24803 case PROMPT:
24804 case PRIVATE:
24805 case PROCEDURE:
24806 case PUBLIC:
24807 case RAISE:
24808 case RANGE:
24809 case RAW:
24810 case REAL:
24811 case RECORD:
24812 case REF:
24813 case RELEASE:
24814 case RELIES_ON:
24815 case RENAME:
24816 case RESULT:
24817 case RETURN:
24818 case RETURNING:
24819 case REVERSE:
24820 case ROLLBACK:
24821 case ROW:
24822 case ROWS:
24823 case ROWID:
24824 case ROWNUM:
24825 case ROWTYPE:
24826 case SAVE:
24827 case SAVEPOINT:
24828 case SECOND:
24829 case SELECT:
24830 case SELF:
24831 case SEPARATE:
24832 case SET:
24833 case SHARE:
24834 case SMALLINT:
24835 case SPACE:
24836 case SQL:
24837 case SQLCODE:
24838 case SQLERRM:
24839 case START:
24840 case STATIC:
24841 case STDDEV:
24842 case SUBTYPE:
24843 case SUBSTITUTABLE:
24844 case SUCCESSFUL:
24845 case SUM:
24846 case SYNONYM:
24847 case SYSDATE:
24848 case SYS_REFCURSOR:
24849 case TABLE:
24850 case TEMPORARY:
24851 case THEN:
24852 case TIME:
24853 case TIMESTAMP:
24854 case TIMEZONE_REGION:
24855 case TIMEZONE_ABBR:
24856 case TIMEZONE_MINUTE:
24857 case TIMEZONE_HOUR:
24858 case TO:
24859 case TRANSACTION:
24860 case TRIGGER:
24861 case TRUE:
24862 case TYPE:
24863 case UI:
24864 case UNDER:
24865 case USING:
24866 case WHILE:
24867 case YES:
24868 case SHOW:
24869 case A:
24870 case UPDATE:
24871 case VARCHAR:
24872 case VARCHAR2:
24873 case DOUBLE:
24874 case DEC:
24875 case PRECISION:
24876 case INT:
24877 case NUMERIC:
24878 case SIGNTYPE:
24879 case NCHAR:
24880 case NVARCHAR2:
24881 case STRING:
24882 case UROWID:
24883 case VARRAY:
24884 case VARYING:
24885 case BFILE:
24886 case BLOB:
24887 case CLOB:
24888 case NCLOB:
24889 case YEAR:
24890 case LOCAL:
24891 case WITH:
24892 case ZONE:
24893 case CHARACTER:
24894 case AFTER:
24895 case BEFORE:
24896 case OLD:
24897 case PARENT:
24898 case ANALYZE:
24899 case ASSOCIATE:
24900 case AUDIT:
24901 case COMPOUND:
24902 case DATABASE:
24903 case CALL:
24904 case DDL:
24905 case DISASSOCIATE:
24906 case EACH:
24907 case FOLLOWS:
24908 case LOGOFF:
24909 case LOGON:
24910 case NESTED:
24911 case NOAUDIT:
24912 case SCHEMA:
24913 case SERVERERROR:
24914 case SHUTDOWN:
24915 case STARTUP:
24916 case STATEMENT:
24917 case STATISTICS:
24918 case SUSPEND:
24919 case TRUNCATE:
24920 case WRAPPED:
24921 case LIBRARY:
24922 case NAME:
24923 case STRUCT:
24924 case CONTEXT:
24925 case PARAMETERS:
24926 case LENGTH:
24927 case TDO:
24928 case MAXLEN:
24929 case CHARSETID:
24930 case CHARSETFORM:
24931 case ACCEPT:
24932 case ACCESSIBLE:
24933 case COPY:
24934 case DEFINE:
24935 case DISCONNECT:
24936 case HOST:
24937 case PRINT:
24938 case QUIT:
24939 case REMARK:
24940 case UNDEFINE:
24941 case VARIABLE:
24942 case WHENEVER:
24943 case ATTACH:
24944 case CAST:
24945 case TREAT:
24946 case TRIM:
24947 case LEFT:
24948 case RIGHT:
24949 case BOTH:
24950 case EMPTY:
24951 case MULTISET:
24952 case SUBMULTISET:
24953 case LEADING:
24954 case TRAILING:
24955 case CHAR_CS:
24956 case NCHAR_CS:
24957 case DBTIMEZONE:
24958 case SESSIONTIMEZONE:
24959 case AUTHENTICATED:
24960 case LINK:
24961 case SHARED:
24962 case DIRECTORY:
24963 case USER:
24964 case IDENTIFIER:
24965 case QUOTED_LITERAL:
24966 case SQLDATA_CLASS:
24967 case CUSTOMDATUM_CLASS:
24968 case ORADATA_CLASS:
24969 case JAVA_INTERFACE_CLASS:
24970 ;
24971 break;
24972 default:
24973 jj_la1[356] = jj_gen;
24974 break label_76;
24975 }
24976 if (jj_2_68(2)) {
24977 TypeMethod();
24978 } else {
24979 switch (jj_nt.kind) {
24980 case REPLACE:
24981 case DEFINER:
24982 case CURRENT_USER:
24983 case SERIALLY_REUSABLE:
24984 case RESTRICT_REFERENCES:
24985 case EXCEPTION_INIT:
24986 case AUTONOMOUS_TRANSACTION:
24987 case LANGUAGE:
24988 case INLINE:
24989 case ADD:
24990 case AGGREGATE:
24991 case ALL:
24992 case ALTER:
24993 case AND:
24994 case ANY:
24995 case ARRAY:
24996 case AS:
24997 case ASC:
24998 case AT:
24999 case ATTRIBUTE:
25000 case AUTHID:
25001 case AVG:
25002 case BETWEEN:
25003 case BINARY_INTEGER:
25004 case BODY:
25005 case BOOLEAN:
25006 case BULK:
25007 case BY:
25008 case BYTE:
25009 case CASCADE:
25010 case CASE:
25011 case CHAR:
25012 case CHAR_BASE:
25013 case CHECK:
25014 case CLOSE:
25015 case CLUSTER:
25016 case COALESCE:
25017 case COLLECT:
25018 case COLUMN:
25019 case COMMENT:
25020 case COMMIT:
25021 case COMPRESS:
25022 case CONNECT:
25023 case CONSTANT:
25024 case CONSTRUCTOR:
25025 case CONTINUE:
25026 case CONVERT:
25027 case CREATE:
25028 case CURRENT:
25029 case CURRVAL:
25030 case CURSOR:
25031 case DATA:
25032 case DATE:
25033 case DAY:
25034 case DECLARE:
25035 case DECIMAL:
25036 case _DEFAULT:
25037 case DELETE:
25038 case DESC:
25039 case DISABLE:
25040 case DISTINCT:
25041 case DO:
25042 case DROP:
25043 case EDITIONABLE:
25044 case ELEMENT:
25045 case ELSE:
25046 case ELSIF:
25047 case ENABLE:
25048 case ESCAPE:
25049 case EXCEPT:
25050 case EXCEPTION:
25051 case EXCEPTIONS:
25052 case EXCLUSIVE:
25053 case EXECUTE:
25054 case EXISTS:
25055 case EXIT:
25056 case EXTERNAL:
25057 case EXTENDS:
25058 case EXTRACT:
25059 case FALSE:
25060 case FETCH:
25061 case FINAL:
25062 case FLOAT:
25063 case FOR:
25064 case FORALL:
25065 case FORCE:
25066 case FROM:
25067 case FUNCTION:
25068 case GLOBAL:
25069 case GOTO:
25070 case GROUP:
25071 case HASH:
25072 case HAVING:
25073 case HEAP:
25074 case HOUR:
25075 case IF:
25076 case IMMEDIATE:
25077 case IN:
25078 case INDEX:
25079 case INDICES:
25080 case INDEXTYPE:
25081 case INDICATOR:
25082 case INSERT:
25083 case INSTANTIABLE:
25084 case INTEGER:
25085 case INTERFACE:
25086 case INTERSECT:
25087 case INTERVAL:
25088 case INTO:
25089 case INVALIDATE:
25090 case IS:
25091 case ISOLATION:
25092 case JAVA:
25093 case LEVEL:
25094 case LIKE:
25095 case LIMIT:
25096 case LIMITED:
25097 case LOCK:
25098 case LONG:
25099 case LOOP:
25100 case MAP:
25101 case MAX:
25102 case MEMBER:
25103 case MERGE:
25104 case MIN:
25105 case MINUS:
25106 case MINUTE:
25107 case MLSLABEL:
25108 case MODIFY:
25109 case MOD:
25110 case MODE:
25111 case MONTH:
25112 case NATURAL:
25113 case NATURALN:
25114 case NEW:
25115 case NEXTVAL:
25116 case NO:
25117 case NOCOPY:
25118 case NONEDITIONABLE:
25119 case NOT:
25120 case NOWAIT:
25121 case NULL:
25122 case NULLIF:
25123 case NUMBER:
25124 case BFILE_BASE:
25125 case BLOB_BASE:
25126 case CLOB_BASE:
25127 case DATE_BASE:
25128 case NUMBER_BASE:
25129 case OBJECT:
25130 case OCIROWID:
25131 case OF:
25132 case OID:
25133 case ON:
25134 case OPAQUE:
25135 case OPEN:
25136 case OPERATOR:
25137 case OPTION:
25138 case OR:
25139 case ORDER:
25140 case ORGANIZATION:
25141 case OTHERS:
25142 case OUT:
25143 case OVERRIDING:
25144 case PACKAGE:
25145 case PARTITION:
25146 case PCTFREE:
25147 case PLS_INTEGER:
25148 case POSITIVE:
25149 case POSITIVEN:
25150 case PRESERVE:
25151 case PRIOR:
25152 case PROMPT:
25153 case PRIVATE:
25154 case PROCEDURE:
25155 case PUBLIC:
25156 case RAISE:
25157 case RANGE:
25158 case RAW:
25159 case REAL:
25160 case RECORD:
25161 case REF:
25162 case RELEASE:
25163 case RELIES_ON:
25164 case RENAME:
25165 case RESULT:
25166 case RETURN:
25167 case RETURNING:
25168 case REVERSE:
25169 case ROLLBACK:
25170 case ROW:
25171 case ROWS:
25172 case ROWID:
25173 case ROWNUM:
25174 case ROWTYPE:
25175 case SAVE:
25176 case SAVEPOINT:
25177 case SECOND:
25178 case SELECT:
25179 case SELF:
25180 case SEPARATE:
25181 case SET:
25182 case SHARE:
25183 case SMALLINT:
25184 case SPACE:
25185 case SQL:
25186 case SQLCODE:
25187 case SQLERRM:
25188 case START:
25189 case STATIC:
25190 case STDDEV:
25191 case SUBTYPE:
25192 case SUBSTITUTABLE:
25193 case SUCCESSFUL:
25194 case SUM:
25195 case SYNONYM:
25196 case SYSDATE:
25197 case SYS_REFCURSOR:
25198 case TABLE:
25199 case TEMPORARY:
25200 case THEN:
25201 case TIME:
25202 case TIMESTAMP:
25203 case TIMEZONE_REGION:
25204 case TIMEZONE_ABBR:
25205 case TIMEZONE_MINUTE:
25206 case TIMEZONE_HOUR:
25207 case TO:
25208 case TRANSACTION:
25209 case TRIGGER:
25210 case TRUE:
25211 case TYPE:
25212 case UI:
25213 case UNDER:
25214 case USING:
25215 case WHILE:
25216 case YES:
25217 case SHOW:
25218 case A:
25219 case UPDATE:
25220 case VARCHAR:
25221 case VARCHAR2:
25222 case DOUBLE:
25223 case DEC:
25224 case PRECISION:
25225 case INT:
25226 case NUMERIC:
25227 case SIGNTYPE:
25228 case NCHAR:
25229 case NVARCHAR2:
25230 case STRING:
25231 case UROWID:
25232 case VARRAY:
25233 case VARYING:
25234 case BFILE:
25235 case BLOB:
25236 case CLOB:
25237 case NCLOB:
25238 case YEAR:
25239 case LOCAL:
25240 case WITH:
25241 case ZONE:
25242 case CHARACTER:
25243 case AFTER:
25244 case BEFORE:
25245 case OLD:
25246 case PARENT:
25247 case ANALYZE:
25248 case ASSOCIATE:
25249 case AUDIT:
25250 case COMPOUND:
25251 case DATABASE:
25252 case CALL:
25253 case DDL:
25254 case DISASSOCIATE:
25255 case EACH:
25256 case FOLLOWS:
25257 case LOGOFF:
25258 case LOGON:
25259 case NESTED:
25260 case NOAUDIT:
25261 case SCHEMA:
25262 case SERVERERROR:
25263 case SHUTDOWN:
25264 case STARTUP:
25265 case STATEMENT:
25266 case STATISTICS:
25267 case SUSPEND:
25268 case TRUNCATE:
25269 case WRAPPED:
25270 case LIBRARY:
25271 case NAME:
25272 case STRUCT:
25273 case CONTEXT:
25274 case PARAMETERS:
25275 case LENGTH:
25276 case TDO:
25277 case MAXLEN:
25278 case CHARSETID:
25279 case CHARSETFORM:
25280 case ACCEPT:
25281 case ACCESSIBLE:
25282 case COPY:
25283 case DEFINE:
25284 case DISCONNECT:
25285 case HOST:
25286 case PRINT:
25287 case QUIT:
25288 case REMARK:
25289 case UNDEFINE:
25290 case VARIABLE:
25291 case WHENEVER:
25292 case ATTACH:
25293 case CAST:
25294 case TREAT:
25295 case TRIM:
25296 case LEFT:
25297 case RIGHT:
25298 case BOTH:
25299 case EMPTY:
25300 case MULTISET:
25301 case SUBMULTISET:
25302 case LEADING:
25303 case TRAILING:
25304 case CHAR_CS:
25305 case NCHAR_CS:
25306 case DBTIMEZONE:
25307 case SESSIONTIMEZONE:
25308 case AUTHENTICATED:
25309 case LINK:
25310 case SHARED:
25311 case DIRECTORY:
25312 case USER:
25313 case IDENTIFIER:
25314 case QUOTED_LITERAL:
25315 case SQLDATA_CLASS:
25316 case CUSTOMDATUM_CLASS:
25317 case ORADATA_CLASS:
25318 case JAVA_INTERFACE_CLASS:
25319 AttributeDeclaration();
25320 break;
25321 case PRAGMA:
25322 PragmaClause();
25323 break;
25324 default:
25325 jj_la1[357] = jj_gen;
25326 jj_consume_token(-1);
25327 throw new ParseException();
25328 }
25329 }
25330 }
25331 label_77:
25332 while (true) {
25333 switch (jj_nt.kind) {
25334 case 6:
25335 ;
25336 break;
25337 default:
25338 jj_la1[358] = jj_gen;
25339 break label_77;
25340 }
25341 jj_consume_token(6);
25342 switch (jj_nt.kind) {
25343 case CONSTRUCTOR:
25344 case FINAL:
25345 case INSTANTIABLE:
25346 case MAP:
25347 case MEMBER:
25348 case NOT:
25349 case ORDER:
25350 case OVERRIDING:
25351 case STATIC:
25352 TypeMethod();
25353 break;
25354 default:
25355 jj_la1[359] = jj_gen;
25356 if (jj_2_69(2)) {
25357 AttributeDeclaration();
25358 } else {
25359 switch (jj_nt.kind) {
25360 case PRAGMA:
25361 PragmaClause();
25362 break;
25363 default:
25364 jj_la1[360] = jj_gen;
25365 jj_consume_token(-1);
25366 throw new ParseException();
25367 }
25368 }
25369 }
25370 }
25371 jj_consume_token(7);
25372 break;
25373 default:
25374 jj_la1[361] = jj_gen;
25375 ;
25376 }
25377 label_78:
25378 while (true) {
25379 switch (jj_nt.kind) {
25380 case FINAL:
25381 case INSTANTIABLE:
25382 case NOT:
25383 case NULL:
25384 ;
25385 break;
25386 default:
25387 jj_la1[362] = jj_gen;
25388 break label_78;
25389 }
25390 switch (jj_nt.kind) {
25391 case NOT:
25392 jj_consume_token(NOT);
25393 break;
25394 default:
25395 jj_la1[363] = jj_gen;
25396 ;
25397 }
25398 switch (jj_nt.kind) {
25399 case FINAL:
25400 jj_consume_token(FINAL);
25401 break;
25402 case INSTANTIABLE:
25403 jj_consume_token(INSTANTIABLE);
25404 break;
25405 case NULL:
25406 jj_consume_token(NULL);
25407 break;
25408 default:
25409 jj_la1[364] = jj_gen;
25410 jj_consume_token(-1);
25411 throw new ParseException();
25412 }
25413 }
25414 label_79:
25415 while (true) {
25416 switch (jj_nt.kind) {
25417 case ALTER:
25418 ;
25419 break;
25420 default:
25421 jj_la1[365] = jj_gen;
25422 break label_79;
25423 }
25424 AlterTypeSpec();
25425 }
25426 switch (jj_nt.kind) {
25427 case 1:
25428 case 4:
25429 switch (jj_nt.kind) {
25430 case 4:
25431 jj_consume_token(4);
25432 break;
25433 case 1:
25434 jj_consume_token(1);
25435 break;
25436 default:
25437 jj_la1[366] = jj_gen;
25438 jj_consume_token(-1);
25439 throw new ParseException();
25440 }
25441 label_80:
25442 while (true) {
25443 switch (jj_nt.kind) {
25444 case ALTER:
25445 ;
25446 break;
25447 default:
25448 jj_la1[367] = jj_gen;
25449 break label_80;
25450 }
25451 AlterTypeSpec();
25452 switch (jj_nt.kind) {
25453 case 1:
25454 jj_consume_token(1);
25455 break;
25456 case 4:
25457 jj_consume_token(4);
25458 break;
25459 default:
25460 jj_la1[368] = jj_gen;
25461 jj_consume_token(-1);
25462 throw new ParseException();
25463 }
25464 }
25465 break;
25466 default:
25467 jj_la1[369] = jj_gen;
25468 ;
25469 }
25470 jjtree.closeNodeScope(jjtn000, true);
25471 jjtc000 = false;
25472 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
25473 } catch (Throwable jjte000) {
25474 if (jjtc000) {
25475 jjtree.clearNodeScope(jjtn000);
25476 jjtc000 = false;
25477 } else {
25478 jjtree.popNode();
25479 }
25480 if (jjte000 instanceof RuntimeException) {
25481 {if (true) throw (RuntimeException)jjte000;}
25482 }
25483 if (jjte000 instanceof ParseException) {
25484 {if (true) throw (ParseException)jjte000;}
25485 }
25486 {if (true) throw (Error)jjte000;}
25487 } finally {
25488 if (jjtc000) {
25489 jjtree.closeNodeScope(jjtn000, true);
25490 }
25491 }
25492 throw new Error("Missing return statement in function");
25493 }
25494
25495 final public ASTAlterTypeSpec AlterTypeSpec() throws ParseException {
25496
25497 ASTAlterTypeSpec jjtn000 = new ASTAlterTypeSpec(this, JJTALTERTYPESPEC);
25498 boolean jjtc000 = true;
25499 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
25500 try {
25501 jj_consume_token(ALTER);
25502 jj_consume_token(TYPE);
25503 simpleNode = QualifiedName();
25504 label_81:
25505 while (true) {
25506 switch (jj_nt.kind) {
25507 case 6:
25508 case ADD:
25509 case DROP:
25510 case MODIFY:
25511 ;
25512 break;
25513 default:
25514 jj_la1[370] = jj_gen;
25515 break label_81;
25516 }
25517 switch (jj_nt.kind) {
25518 case 6:
25519 case ADD:
25520 case MODIFY:
25521 switch (jj_nt.kind) {
25522 case 6:
25523 jj_consume_token(6);
25524 break;
25525 default:
25526 jj_la1[371] = jj_gen;
25527 ;
25528 }
25529 switch (jj_nt.kind) {
25530 case ADD:
25531 jj_consume_token(ADD);
25532 break;
25533 case MODIFY:
25534 jj_consume_token(MODIFY);
25535 break;
25536 default:
25537 jj_la1[372] = jj_gen;
25538 jj_consume_token(-1);
25539 throw new ParseException();
25540 }
25541 label_82:
25542 while (true) {
25543 switch (jj_nt.kind) {
25544 case CONSTRUCTOR:
25545 case FINAL:
25546 case INSTANTIABLE:
25547 case MAP:
25548 case MEMBER:
25549 case NOT:
25550 case ORDER:
25551 case OVERRIDING:
25552 case STATIC:
25553 TypeMethod();
25554 break;
25555 case ATTRIBUTE:
25556 jj_consume_token(ATTRIBUTE);
25557 label_83:
25558 while (true) {
25559 switch (jj_nt.kind) {
25560 case 5:
25561 ;
25562 break;
25563 default:
25564 jj_la1[373] = jj_gen;
25565 break label_83;
25566 }
25567 jj_consume_token(5);
25568 }
25569 AttributeDeclaration();
25570 label_84:
25571 while (true) {
25572 switch (jj_nt.kind) {
25573 case 6:
25574 ;
25575 break;
25576 default:
25577 jj_la1[374] = jj_gen;
25578 break label_84;
25579 }
25580 jj_consume_token(6);
25581 AttributeDeclaration();
25582 }
25583 label_85:
25584 while (true) {
25585 switch (jj_nt.kind) {
25586 case 7:
25587 ;
25588 break;
25589 default:
25590 jj_la1[375] = jj_gen;
25591 break label_85;
25592 }
25593 jj_consume_token(7);
25594 }
25595 break;
25596 case LIMIT:
25597 jj_consume_token(LIMIT);
25598 NumericLiteral();
25599 break;
25600 case ELEMENT:
25601 jj_consume_token(ELEMENT);
25602 jj_consume_token(TYPE);
25603 Datatype();
25604 break;
25605 default:
25606 jj_la1[376] = jj_gen;
25607 jj_consume_token(-1);
25608 throw new ParseException();
25609 }
25610 switch (jj_nt.kind) {
25611 case ATTRIBUTE:
25612 case CONSTRUCTOR:
25613 case ELEMENT:
25614 case FINAL:
25615 case INSTANTIABLE:
25616 case LIMIT:
25617 case MAP:
25618 case MEMBER:
25619 case NOT:
25620 case ORDER:
25621 case OVERRIDING:
25622 case STATIC:
25623 ;
25624 break;
25625 default:
25626 jj_la1[377] = jj_gen;
25627 break label_82;
25628 }
25629 }
25630 break;
25631 case DROP:
25632 jj_consume_token(DROP);
25633 label_86:
25634 while (true) {
25635 switch (jj_nt.kind) {
25636 case ATTRIBUTE:
25637 jj_consume_token(ATTRIBUTE);
25638 label_87:
25639 while (true) {
25640 switch (jj_nt.kind) {
25641 case 5:
25642 ;
25643 break;
25644 default:
25645 jj_la1[378] = jj_gen;
25646 break label_87;
25647 }
25648 jj_consume_token(5);
25649 }
25650 Attribute();
25651 label_88:
25652 while (true) {
25653 switch (jj_nt.kind) {
25654 case 6:
25655 ;
25656 break;
25657 default:
25658 jj_la1[379] = jj_gen;
25659 break label_88;
25660 }
25661 jj_consume_token(6);
25662 Attribute();
25663 }
25664 label_89:
25665 while (true) {
25666 switch (jj_nt.kind) {
25667 case 7:
25668 ;
25669 break;
25670 default:
25671 jj_la1[380] = jj_gen;
25672 break label_89;
25673 }
25674 jj_consume_token(7);
25675 }
25676 break;
25677 case CONSTRUCTOR:
25678 case FINAL:
25679 case INSTANTIABLE:
25680 case MAP:
25681 case MEMBER:
25682 case NOT:
25683 case ORDER:
25684 case OVERRIDING:
25685 case STATIC:
25686 TypeMethod();
25687 break;
25688 default:
25689 jj_la1[381] = jj_gen;
25690 jj_consume_token(-1);
25691 throw new ParseException();
25692 }
25693 switch (jj_nt.kind) {
25694 case ATTRIBUTE:
25695 case CONSTRUCTOR:
25696 case FINAL:
25697 case INSTANTIABLE:
25698 case MAP:
25699 case MEMBER:
25700 case NOT:
25701 case ORDER:
25702 case OVERRIDING:
25703 case STATIC:
25704 ;
25705 break;
25706 default:
25707 jj_la1[382] = jj_gen;
25708 break label_86;
25709 }
25710 }
25711 break;
25712 default:
25713 jj_la1[383] = jj_gen;
25714 jj_consume_token(-1);
25715 throw new ParseException();
25716 }
25717 }
25718 switch (jj_nt.kind) {
25719 case REPLACE:
25720 jj_consume_token(REPLACE);
25721 label_90:
25722 while (true) {
25723 if (jj_2_70(2)) {
25724 ;
25725 } else {
25726 break label_90;
25727 }
25728 switch (jj_nt.kind) {
25729 case AUTHID:
25730 jj_consume_token(AUTHID);
25731 switch (jj_nt.kind) {
25732 case CURRENT_USER:
25733 jj_consume_token(CURRENT_USER);
25734 break;
25735 case DEFINER:
25736 jj_consume_token(DEFINER);
25737 break;
25738 default:
25739 jj_la1[384] = jj_gen;
25740 jj_consume_token(-1);
25741 throw new ParseException();
25742 }
25743 break;
25744 case ACCESSIBLE:
25745 AccessibleByClause();
25746 break;
25747 default:
25748 jj_la1[385] = jj_gen;
25749 jj_consume_token(-1);
25750 throw new ParseException();
25751 }
25752 }
25753 switch (jj_nt.kind) {
25754 case IS:
25755 jj_consume_token(IS);
25756 break;
25757 case AS:
25758 jj_consume_token(AS);
25759 break;
25760 default:
25761 jj_la1[386] = jj_gen;
25762 jj_consume_token(-1);
25763 throw new ParseException();
25764 }
25765 jj_consume_token(OBJECT);
25766 jj_consume_token(5);
25767 if (jj_2_71(2)) {
25768 TypeMethod();
25769 } else {
25770 switch (jj_nt.kind) {
25771 case REPLACE:
25772 case DEFINER:
25773 case CURRENT_USER:
25774 case SERIALLY_REUSABLE:
25775 case RESTRICT_REFERENCES:
25776 case EXCEPTION_INIT:
25777 case AUTONOMOUS_TRANSACTION:
25778 case LANGUAGE:
25779 case INLINE:
25780 case ADD:
25781 case AGGREGATE:
25782 case ALL:
25783 case ALTER:
25784 case AND:
25785 case ANY:
25786 case ARRAY:
25787 case AS:
25788 case ASC:
25789 case AT:
25790 case ATTRIBUTE:
25791 case AUTHID:
25792 case AVG:
25793 case BETWEEN:
25794 case BINARY_INTEGER:
25795 case BODY:
25796 case BOOLEAN:
25797 case BULK:
25798 case BY:
25799 case BYTE:
25800 case CASCADE:
25801 case CASE:
25802 case CHAR:
25803 case CHAR_BASE:
25804 case CHECK:
25805 case CLOSE:
25806 case CLUSTER:
25807 case COALESCE:
25808 case COLLECT:
25809 case COLUMN:
25810 case COMMENT:
25811 case COMMIT:
25812 case COMPRESS:
25813 case CONNECT:
25814 case CONSTANT:
25815 case CONSTRUCTOR:
25816 case CONTINUE:
25817 case CONVERT:
25818 case CREATE:
25819 case CURRENT:
25820 case CURRVAL:
25821 case CURSOR:
25822 case DATA:
25823 case DATE:
25824 case DAY:
25825 case DECLARE:
25826 case DECIMAL:
25827 case _DEFAULT:
25828 case DELETE:
25829 case DESC:
25830 case DISABLE:
25831 case DISTINCT:
25832 case DO:
25833 case DROP:
25834 case EDITIONABLE:
25835 case ELEMENT:
25836 case ELSE:
25837 case ELSIF:
25838 case ENABLE:
25839 case ESCAPE:
25840 case EXCEPT:
25841 case EXCEPTION:
25842 case EXCEPTIONS:
25843 case EXCLUSIVE:
25844 case EXECUTE:
25845 case EXISTS:
25846 case EXIT:
25847 case EXTERNAL:
25848 case EXTENDS:
25849 case EXTRACT:
25850 case FALSE:
25851 case FETCH:
25852 case FINAL:
25853 case FLOAT:
25854 case FOR:
25855 case FORALL:
25856 case FORCE:
25857 case FROM:
25858 case FUNCTION:
25859 case GLOBAL:
25860 case GOTO:
25861 case GROUP:
25862 case HASH:
25863 case HAVING:
25864 case HEAP:
25865 case HOUR:
25866 case IF:
25867 case IMMEDIATE:
25868 case IN:
25869 case INDEX:
25870 case INDICES:
25871 case INDEXTYPE:
25872 case INDICATOR:
25873 case INSERT:
25874 case INSTANTIABLE:
25875 case INTEGER:
25876 case INTERFACE:
25877 case INTERSECT:
25878 case INTERVAL:
25879 case INTO:
25880 case INVALIDATE:
25881 case IS:
25882 case ISOLATION:
25883 case JAVA:
25884 case LEVEL:
25885 case LIKE:
25886 case LIMIT:
25887 case LIMITED:
25888 case LOCK:
25889 case LONG:
25890 case LOOP:
25891 case MAP:
25892 case MAX:
25893 case MEMBER:
25894 case MERGE:
25895 case MIN:
25896 case MINUS:
25897 case MINUTE:
25898 case MLSLABEL:
25899 case MODIFY:
25900 case MOD:
25901 case MODE:
25902 case MONTH:
25903 case NATURAL:
25904 case NATURALN:
25905 case NEW:
25906 case NEXTVAL:
25907 case NO:
25908 case NOCOPY:
25909 case NONEDITIONABLE:
25910 case NOT:
25911 case NOWAIT:
25912 case NULL:
25913 case NULLIF:
25914 case NUMBER:
25915 case BFILE_BASE:
25916 case BLOB_BASE:
25917 case CLOB_BASE:
25918 case DATE_BASE:
25919 case NUMBER_BASE:
25920 case OBJECT:
25921 case OCIROWID:
25922 case OF:
25923 case OID:
25924 case ON:
25925 case OPAQUE:
25926 case OPEN:
25927 case OPERATOR:
25928 case OPTION:
25929 case OR:
25930 case ORDER:
25931 case ORGANIZATION:
25932 case OTHERS:
25933 case OUT:
25934 case OVERRIDING:
25935 case PACKAGE:
25936 case PARTITION:
25937 case PCTFREE:
25938 case PLS_INTEGER:
25939 case POSITIVE:
25940 case POSITIVEN:
25941 case PRESERVE:
25942 case PRIOR:
25943 case PROMPT:
25944 case PRIVATE:
25945 case PROCEDURE:
25946 case PUBLIC:
25947 case RAISE:
25948 case RANGE:
25949 case RAW:
25950 case REAL:
25951 case RECORD:
25952 case REF:
25953 case RELEASE:
25954 case RELIES_ON:
25955 case RENAME:
25956 case RESULT:
25957 case RETURN:
25958 case RETURNING:
25959 case REVERSE:
25960 case ROLLBACK:
25961 case ROW:
25962 case ROWS:
25963 case ROWID:
25964 case ROWNUM:
25965 case ROWTYPE:
25966 case SAVE:
25967 case SAVEPOINT:
25968 case SECOND:
25969 case SELECT:
25970 case SELF:
25971 case SEPARATE:
25972 case SET:
25973 case SHARE:
25974 case SMALLINT:
25975 case SPACE:
25976 case SQL:
25977 case SQLCODE:
25978 case SQLERRM:
25979 case START:
25980 case STATIC:
25981 case STDDEV:
25982 case SUBTYPE:
25983 case SUBSTITUTABLE:
25984 case SUCCESSFUL:
25985 case SUM:
25986 case SYNONYM:
25987 case SYSDATE:
25988 case SYS_REFCURSOR:
25989 case TABLE:
25990 case TEMPORARY:
25991 case THEN:
25992 case TIME:
25993 case TIMESTAMP:
25994 case TIMEZONE_REGION:
25995 case TIMEZONE_ABBR:
25996 case TIMEZONE_MINUTE:
25997 case TIMEZONE_HOUR:
25998 case TO:
25999 case TRANSACTION:
26000 case TRIGGER:
26001 case TRUE:
26002 case TYPE:
26003 case UI:
26004 case UNDER:
26005 case USING:
26006 case WHILE:
26007 case YES:
26008 case SHOW:
26009 case A:
26010 case UPDATE:
26011 case VARCHAR:
26012 case VARCHAR2:
26013 case DOUBLE:
26014 case DEC:
26015 case PRECISION:
26016 case INT:
26017 case NUMERIC:
26018 case SIGNTYPE:
26019 case NCHAR:
26020 case NVARCHAR2:
26021 case STRING:
26022 case UROWID:
26023 case VARRAY:
26024 case VARYING:
26025 case BFILE:
26026 case BLOB:
26027 case CLOB:
26028 case NCLOB:
26029 case YEAR:
26030 case LOCAL:
26031 case WITH:
26032 case ZONE:
26033 case CHARACTER:
26034 case AFTER:
26035 case BEFORE:
26036 case OLD:
26037 case PARENT:
26038 case ANALYZE:
26039 case ASSOCIATE:
26040 case AUDIT:
26041 case COMPOUND:
26042 case DATABASE:
26043 case CALL:
26044 case DDL:
26045 case DISASSOCIATE:
26046 case EACH:
26047 case FOLLOWS:
26048 case LOGOFF:
26049 case LOGON:
26050 case NESTED:
26051 case NOAUDIT:
26052 case SCHEMA:
26053 case SERVERERROR:
26054 case SHUTDOWN:
26055 case STARTUP:
26056 case STATEMENT:
26057 case STATISTICS:
26058 case SUSPEND:
26059 case TRUNCATE:
26060 case WRAPPED:
26061 case LIBRARY:
26062 case NAME:
26063 case STRUCT:
26064 case CONTEXT:
26065 case PARAMETERS:
26066 case LENGTH:
26067 case TDO:
26068 case MAXLEN:
26069 case CHARSETID:
26070 case CHARSETFORM:
26071 case ACCEPT:
26072 case ACCESSIBLE:
26073 case COPY:
26074 case DEFINE:
26075 case DISCONNECT:
26076 case HOST:
26077 case PRINT:
26078 case QUIT:
26079 case REMARK:
26080 case UNDEFINE:
26081 case VARIABLE:
26082 case WHENEVER:
26083 case ATTACH:
26084 case CAST:
26085 case TREAT:
26086 case TRIM:
26087 case LEFT:
26088 case RIGHT:
26089 case BOTH:
26090 case EMPTY:
26091 case MULTISET:
26092 case SUBMULTISET:
26093 case LEADING:
26094 case TRAILING:
26095 case CHAR_CS:
26096 case NCHAR_CS:
26097 case DBTIMEZONE:
26098 case SESSIONTIMEZONE:
26099 case AUTHENTICATED:
26100 case LINK:
26101 case SHARED:
26102 case DIRECTORY:
26103 case USER:
26104 case IDENTIFIER:
26105 case QUOTED_LITERAL:
26106 case SQLDATA_CLASS:
26107 case CUSTOMDATUM_CLASS:
26108 case ORADATA_CLASS:
26109 case JAVA_INTERFACE_CLASS:
26110 AttributeDeclaration();
26111 break;
26112 default:
26113 jj_la1[387] = jj_gen;
26114 jj_consume_token(-1);
26115 throw new ParseException();
26116 }
26117 }
26118 label_91:
26119 while (true) {
26120 switch (jj_nt.kind) {
26121 case 6:
26122 ;
26123 break;
26124 default:
26125 jj_la1[388] = jj_gen;
26126 break label_91;
26127 }
26128 jj_consume_token(6);
26129 if (jj_2_72(2)) {
26130 TypeMethod();
26131 } else {
26132 switch (jj_nt.kind) {
26133 case REPLACE:
26134 case DEFINER:
26135 case CURRENT_USER:
26136 case SERIALLY_REUSABLE:
26137 case RESTRICT_REFERENCES:
26138 case EXCEPTION_INIT:
26139 case AUTONOMOUS_TRANSACTION:
26140 case LANGUAGE:
26141 case INLINE:
26142 case ADD:
26143 case AGGREGATE:
26144 case ALL:
26145 case ALTER:
26146 case AND:
26147 case ANY:
26148 case ARRAY:
26149 case AS:
26150 case ASC:
26151 case AT:
26152 case ATTRIBUTE:
26153 case AUTHID:
26154 case AVG:
26155 case BETWEEN:
26156 case BINARY_INTEGER:
26157 case BODY:
26158 case BOOLEAN:
26159 case BULK:
26160 case BY:
26161 case BYTE:
26162 case CASCADE:
26163 case CASE:
26164 case CHAR:
26165 case CHAR_BASE:
26166 case CHECK:
26167 case CLOSE:
26168 case CLUSTER:
26169 case COALESCE:
26170 case COLLECT:
26171 case COLUMN:
26172 case COMMENT:
26173 case COMMIT:
26174 case COMPRESS:
26175 case CONNECT:
26176 case CONSTANT:
26177 case CONSTRUCTOR:
26178 case CONTINUE:
26179 case CONVERT:
26180 case CREATE:
26181 case CURRENT:
26182 case CURRVAL:
26183 case CURSOR:
26184 case DATA:
26185 case DATE:
26186 case DAY:
26187 case DECLARE:
26188 case DECIMAL:
26189 case _DEFAULT:
26190 case DELETE:
26191 case DESC:
26192 case DISABLE:
26193 case DISTINCT:
26194 case DO:
26195 case DROP:
26196 case EDITIONABLE:
26197 case ELEMENT:
26198 case ELSE:
26199 case ELSIF:
26200 case ENABLE:
26201 case ESCAPE:
26202 case EXCEPT:
26203 case EXCEPTION:
26204 case EXCEPTIONS:
26205 case EXCLUSIVE:
26206 case EXECUTE:
26207 case EXISTS:
26208 case EXIT:
26209 case EXTERNAL:
26210 case EXTENDS:
26211 case EXTRACT:
26212 case FALSE:
26213 case FETCH:
26214 case FINAL:
26215 case FLOAT:
26216 case FOR:
26217 case FORALL:
26218 case FORCE:
26219 case FROM:
26220 case FUNCTION:
26221 case GLOBAL:
26222 case GOTO:
26223 case GROUP:
26224 case HASH:
26225 case HAVING:
26226 case HEAP:
26227 case HOUR:
26228 case IF:
26229 case IMMEDIATE:
26230 case IN:
26231 case INDEX:
26232 case INDICES:
26233 case INDEXTYPE:
26234 case INDICATOR:
26235 case INSERT:
26236 case INSTANTIABLE:
26237 case INTEGER:
26238 case INTERFACE:
26239 case INTERSECT:
26240 case INTERVAL:
26241 case INTO:
26242 case INVALIDATE:
26243 case IS:
26244 case ISOLATION:
26245 case JAVA:
26246 case LEVEL:
26247 case LIKE:
26248 case LIMIT:
26249 case LIMITED:
26250 case LOCK:
26251 case LONG:
26252 case LOOP:
26253 case MAP:
26254 case MAX:
26255 case MEMBER:
26256 case MERGE:
26257 case MIN:
26258 case MINUS:
26259 case MINUTE:
26260 case MLSLABEL:
26261 case MODIFY:
26262 case MOD:
26263 case MODE:
26264 case MONTH:
26265 case NATURAL:
26266 case NATURALN:
26267 case NEW:
26268 case NEXTVAL:
26269 case NO:
26270 case NOCOPY:
26271 case NONEDITIONABLE:
26272 case NOT:
26273 case NOWAIT:
26274 case NULL:
26275 case NULLIF:
26276 case NUMBER:
26277 case BFILE_BASE:
26278 case BLOB_BASE:
26279 case CLOB_BASE:
26280 case DATE_BASE:
26281 case NUMBER_BASE:
26282 case OBJECT:
26283 case OCIROWID:
26284 case OF:
26285 case OID:
26286 case ON:
26287 case OPAQUE:
26288 case OPEN:
26289 case OPERATOR:
26290 case OPTION:
26291 case OR:
26292 case ORDER:
26293 case ORGANIZATION:
26294 case OTHERS:
26295 case OUT:
26296 case OVERRIDING:
26297 case PACKAGE:
26298 case PARTITION:
26299 case PCTFREE:
26300 case PLS_INTEGER:
26301 case POSITIVE:
26302 case POSITIVEN:
26303 case PRESERVE:
26304 case PRIOR:
26305 case PROMPT:
26306 case PRIVATE:
26307 case PROCEDURE:
26308 case PUBLIC:
26309 case RAISE:
26310 case RANGE:
26311 case RAW:
26312 case REAL:
26313 case RECORD:
26314 case REF:
26315 case RELEASE:
26316 case RELIES_ON:
26317 case RENAME:
26318 case RESULT:
26319 case RETURN:
26320 case RETURNING:
26321 case REVERSE:
26322 case ROLLBACK:
26323 case ROW:
26324 case ROWS:
26325 case ROWID:
26326 case ROWNUM:
26327 case ROWTYPE:
26328 case SAVE:
26329 case SAVEPOINT:
26330 case SECOND:
26331 case SELECT:
26332 case SELF:
26333 case SEPARATE:
26334 case SET:
26335 case SHARE:
26336 case SMALLINT:
26337 case SPACE:
26338 case SQL:
26339 case SQLCODE:
26340 case SQLERRM:
26341 case START:
26342 case STATIC:
26343 case STDDEV:
26344 case SUBTYPE:
26345 case SUBSTITUTABLE:
26346 case SUCCESSFUL:
26347 case SUM:
26348 case SYNONYM:
26349 case SYSDATE:
26350 case SYS_REFCURSOR:
26351 case TABLE:
26352 case TEMPORARY:
26353 case THEN:
26354 case TIME:
26355 case TIMESTAMP:
26356 case TIMEZONE_REGION:
26357 case TIMEZONE_ABBR:
26358 case TIMEZONE_MINUTE:
26359 case TIMEZONE_HOUR:
26360 case TO:
26361 case TRANSACTION:
26362 case TRIGGER:
26363 case TRUE:
26364 case TYPE:
26365 case UI:
26366 case UNDER:
26367 case USING:
26368 case WHILE:
26369 case YES:
26370 case SHOW:
26371 case A:
26372 case UPDATE:
26373 case VARCHAR:
26374 case VARCHAR2:
26375 case DOUBLE:
26376 case DEC:
26377 case PRECISION:
26378 case INT:
26379 case NUMERIC:
26380 case SIGNTYPE:
26381 case NCHAR:
26382 case NVARCHAR2:
26383 case STRING:
26384 case UROWID:
26385 case VARRAY:
26386 case VARYING:
26387 case BFILE:
26388 case BLOB:
26389 case CLOB:
26390 case NCLOB:
26391 case YEAR:
26392 case LOCAL:
26393 case WITH:
26394 case ZONE:
26395 case CHARACTER:
26396 case AFTER:
26397 case BEFORE:
26398 case OLD:
26399 case PARENT:
26400 case ANALYZE:
26401 case ASSOCIATE:
26402 case AUDIT:
26403 case COMPOUND:
26404 case DATABASE:
26405 case CALL:
26406 case DDL:
26407 case DISASSOCIATE:
26408 case EACH:
26409 case FOLLOWS:
26410 case LOGOFF:
26411 case LOGON:
26412 case NESTED:
26413 case NOAUDIT:
26414 case SCHEMA:
26415 case SERVERERROR:
26416 case SHUTDOWN:
26417 case STARTUP:
26418 case STATEMENT:
26419 case STATISTICS:
26420 case SUSPEND:
26421 case TRUNCATE:
26422 case WRAPPED:
26423 case LIBRARY:
26424 case NAME:
26425 case STRUCT:
26426 case CONTEXT:
26427 case PARAMETERS:
26428 case LENGTH:
26429 case TDO:
26430 case MAXLEN:
26431 case CHARSETID:
26432 case CHARSETFORM:
26433 case ACCEPT:
26434 case ACCESSIBLE:
26435 case COPY:
26436 case DEFINE:
26437 case DISCONNECT:
26438 case HOST:
26439 case PRINT:
26440 case QUIT:
26441 case REMARK:
26442 case UNDEFINE:
26443 case VARIABLE:
26444 case WHENEVER:
26445 case ATTACH:
26446 case CAST:
26447 case TREAT:
26448 case TRIM:
26449 case LEFT:
26450 case RIGHT:
26451 case BOTH:
26452 case EMPTY:
26453 case MULTISET:
26454 case SUBMULTISET:
26455 case LEADING:
26456 case TRAILING:
26457 case CHAR_CS:
26458 case NCHAR_CS:
26459 case DBTIMEZONE:
26460 case SESSIONTIMEZONE:
26461 case AUTHENTICATED:
26462 case LINK:
26463 case SHARED:
26464 case DIRECTORY:
26465 case USER:
26466 case IDENTIFIER:
26467 case QUOTED_LITERAL:
26468 case SQLDATA_CLASS:
26469 case CUSTOMDATUM_CLASS:
26470 case ORADATA_CLASS:
26471 case JAVA_INTERFACE_CLASS:
26472 AttributeDeclaration();
26473 break;
26474 default:
26475 jj_la1[389] = jj_gen;
26476 jj_consume_token(-1);
26477 throw new ParseException();
26478 }
26479 }
26480 }
26481 jj_consume_token(7);
26482 break;
26483 default:
26484 jj_la1[390] = jj_gen;
26485 ;
26486 }
26487 label_92:
26488 while (true) {
26489 switch (jj_nt.kind) {
26490 case FINAL:
26491 case INSTANTIABLE:
26492 case NOT:
26493 case NULL:
26494 ;
26495 break;
26496 default:
26497 jj_la1[391] = jj_gen;
26498 break label_92;
26499 }
26500 switch (jj_nt.kind) {
26501 case NOT:
26502 jj_consume_token(NOT);
26503 break;
26504 default:
26505 jj_la1[392] = jj_gen;
26506 ;
26507 }
26508 switch (jj_nt.kind) {
26509 case FINAL:
26510 jj_consume_token(FINAL);
26511 break;
26512 case INSTANTIABLE:
26513 jj_consume_token(INSTANTIABLE);
26514 break;
26515 case NULL:
26516 jj_consume_token(NULL);
26517 break;
26518 default:
26519 jj_la1[393] = jj_gen;
26520 jj_consume_token(-1);
26521 throw new ParseException();
26522 }
26523 }
26524 switch (jj_nt.kind) {
26525 case CASCADE:
26526 case INVALIDATE:
26527 switch (jj_nt.kind) {
26528 case INVALIDATE:
26529 jj_consume_token(INVALIDATE);
26530 break;
26531 case CASCADE:
26532 jj_consume_token(CASCADE);
26533 label_93:
26534 while (true) {
26535 switch (jj_nt.kind) {
26536 case CONVERT:
26537 case INCLUDING:
26538 case NOT:
26539 ;
26540 break;
26541 default:
26542 jj_la1[394] = jj_gen;
26543 break label_93;
26544 }
26545 switch (jj_nt.kind) {
26546 case INCLUDING:
26547 case NOT:
26548 switch (jj_nt.kind) {
26549 case NOT:
26550 jj_consume_token(NOT);
26551 break;
26552 default:
26553 jj_la1[395] = jj_gen;
26554 ;
26555 }
26556 jj_consume_token(INCLUDING);
26557 jj_consume_token(TABLE);
26558 jj_consume_token(DATA);
26559 break;
26560 case CONVERT:
26561 jj_consume_token(CONVERT);
26562 jj_consume_token(TO);
26563 jj_consume_token(SUBSTITUTABLE);
26564 break;
26565 default:
26566 jj_la1[396] = jj_gen;
26567 jj_consume_token(-1);
26568 throw new ParseException();
26569 }
26570 }
26571 switch (jj_nt.kind) {
26572 case EXCEPTIONS:
26573 case FORCE:
26574 switch (jj_nt.kind) {
26575 case FORCE:
26576 jj_consume_token(FORCE);
26577 break;
26578 default:
26579 jj_la1[397] = jj_gen;
26580 ;
26581 }
26582 jj_consume_token(EXCEPTIONS);
26583 jj_consume_token(INTO);
26584 QualifiedName();
26585 break;
26586 default:
26587 jj_la1[398] = jj_gen;
26588 ;
26589 }
26590 break;
26591 default:
26592 jj_la1[399] = jj_gen;
26593 jj_consume_token(-1);
26594 throw new ParseException();
26595 }
26596 break;
26597 default:
26598 jj_la1[400] = jj_gen;
26599 ;
26600 }
26601 jjtree.closeNodeScope(jjtn000, true);
26602 jjtc000 = false;
26603 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
26604 } catch (Throwable jjte000) {
26605 if (jjtc000) {
26606 jjtree.clearNodeScope(jjtn000);
26607 jjtc000 = false;
26608 } else {
26609 jjtree.popNode();
26610 }
26611 if (jjte000 instanceof RuntimeException) {
26612 {if (true) throw (RuntimeException)jjte000;}
26613 }
26614 if (jjte000 instanceof ParseException) {
26615 {if (true) throw (ParseException)jjte000;}
26616 }
26617 {if (true) throw (Error)jjte000;}
26618 } finally {
26619 if (jjtc000) {
26620 jjtree.closeNodeScope(jjtn000, true);
26621 }
26622 }
26623 throw new Error("Missing return statement in function");
26624 }
26625
26626
26627
26628
26629
26630
26631
26632
26633
26634
26635
26636
26637
26638
26639
26640
26641
26642
26643
26644
26645
26646
26647
26648
26649
26650
26651
26652
26653
26654 final public ASTAttributeDeclaration AttributeDeclaration() throws ParseException {
26655
26656 ASTAttributeDeclaration jjtn000 = new ASTAttributeDeclaration(this, JJTATTRIBUTEDECLARATION);
26657 boolean jjtc000 = true;
26658 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
26659 try {
26660 simpleNode = ID();
26661 Datatype();
26662 jjtree.closeNodeScope(jjtn000, true);
26663 jjtc000 = false;
26664 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
26665 } catch (Throwable jjte000) {
26666 if (jjtc000) {
26667 jjtree.clearNodeScope(jjtn000);
26668 jjtc000 = false;
26669 } else {
26670 jjtree.popNode();
26671 }
26672 if (jjte000 instanceof RuntimeException) {
26673 {if (true) throw (RuntimeException)jjte000;}
26674 }
26675 if (jjte000 instanceof ParseException) {
26676 {if (true) throw (ParseException)jjte000;}
26677 }
26678 {if (true) throw (Error)jjte000;}
26679 } finally {
26680 if (jjtc000) {
26681 jjtree.closeNodeScope(jjtn000, true);
26682 }
26683 }
26684 throw new Error("Missing return statement in function");
26685 }
26686
26687 final public ASTAttribute Attribute() throws ParseException {
26688
26689 ASTAttribute jjtn000 = new ASTAttribute(this, JJTATTRIBUTE);
26690 boolean jjtc000 = true;
26691 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
26692 try {
26693 simpleNode = ID();
26694 jjtree.closeNodeScope(jjtn000, true);
26695 jjtc000 = false;
26696 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
26697 } catch (Throwable jjte000) {
26698 if (jjtc000) {
26699 jjtree.clearNodeScope(jjtn000);
26700 jjtc000 = false;
26701 } else {
26702 jjtree.popNode();
26703 }
26704 if (jjte000 instanceof RuntimeException) {
26705 {if (true) throw (RuntimeException)jjte000;}
26706 }
26707 if (jjte000 instanceof ParseException) {
26708 {if (true) throw (ParseException)jjte000;}
26709 }
26710 {if (true) throw (Error)jjte000;}
26711 } finally {
26712 if (jjtc000) {
26713 jjtree.closeNodeScope(jjtn000, true);
26714 }
26715 }
26716 throw new Error("Missing return statement in function");
26717 }
26718
26719
26720
26721
26722 final public ASTPragmaClause PragmaClause() throws ParseException {
26723
26724 ASTPragmaClause jjtn000 = new ASTPragmaClause(this, JJTPRAGMACLAUSE);
26725 boolean jjtc000 = true;
26726 jjtree.openNodeScope(jjtn000);
26727 try {
26728 jj_consume_token(PRAGMA);
26729 switch (jj_nt.kind) {
26730 case SERIALLY_REUSABLE:
26731 jj_consume_token(SERIALLY_REUSABLE);
26732 break;
26733 case AUTONOMOUS_TRANSACTION:
26734 jj_consume_token(AUTONOMOUS_TRANSACTION);
26735 break;
26736 case RESTRICT_REFERENCES:
26737 jj_consume_token(RESTRICT_REFERENCES);
26738 jj_consume_token(5);
26739 ID();
26740 label_94:
26741 while (true) {
26742 jj_consume_token(6);
26743 switch (jj_nt.kind) {
26744 case REPLACE:
26745 case DEFINER:
26746 case CURRENT_USER:
26747 case SERIALLY_REUSABLE:
26748 case RESTRICT_REFERENCES:
26749 case EXCEPTION_INIT:
26750 case AUTONOMOUS_TRANSACTION:
26751 case LANGUAGE:
26752 case INLINE:
26753 case ADD:
26754 case AGGREGATE:
26755 case ALL:
26756 case ALTER:
26757 case AND:
26758 case ANY:
26759 case ARRAY:
26760 case AS:
26761 case ASC:
26762 case AT:
26763 case ATTRIBUTE:
26764 case AUTHID:
26765 case AVG:
26766 case BETWEEN:
26767 case BINARY_INTEGER:
26768 case BODY:
26769 case BOOLEAN:
26770 case BULK:
26771 case BY:
26772 case BYTE:
26773 case CASCADE:
26774 case CASE:
26775 case CHAR:
26776 case CHAR_BASE:
26777 case CHECK:
26778 case CLOSE:
26779 case CLUSTER:
26780 case COALESCE:
26781 case COLLECT:
26782 case COLUMN:
26783 case COMMENT:
26784 case COMMIT:
26785 case COMPRESS:
26786 case CONNECT:
26787 case CONSTANT:
26788 case CONSTRUCTOR:
26789 case CONTINUE:
26790 case CONVERT:
26791 case CREATE:
26792 case CURRENT:
26793 case CURRVAL:
26794 case CURSOR:
26795 case DATA:
26796 case DATE:
26797 case DAY:
26798 case DECLARE:
26799 case DECIMAL:
26800 case _DEFAULT:
26801 case DELETE:
26802 case DESC:
26803 case DISABLE:
26804 case DISTINCT:
26805 case DO:
26806 case DROP:
26807 case EDITIONABLE:
26808 case ELEMENT:
26809 case ELSE:
26810 case ELSIF:
26811 case ENABLE:
26812 case ESCAPE:
26813 case EXCEPT:
26814 case EXCEPTION:
26815 case EXCEPTIONS:
26816 case EXCLUSIVE:
26817 case EXECUTE:
26818 case EXISTS:
26819 case EXIT:
26820 case EXTERNAL:
26821 case EXTENDS:
26822 case EXTRACT:
26823 case FALSE:
26824 case FETCH:
26825 case FINAL:
26826 case FLOAT:
26827 case FOR:
26828 case FORALL:
26829 case FORCE:
26830 case FROM:
26831 case FUNCTION:
26832 case GLOBAL:
26833 case GOTO:
26834 case GROUP:
26835 case HASH:
26836 case HAVING:
26837 case HEAP:
26838 case HOUR:
26839 case IF:
26840 case IMMEDIATE:
26841 case IN:
26842 case INDEX:
26843 case INDICES:
26844 case INDEXTYPE:
26845 case INDICATOR:
26846 case INSERT:
26847 case INSTANTIABLE:
26848 case INTEGER:
26849 case INTERFACE:
26850 case INTERSECT:
26851 case INTERVAL:
26852 case INTO:
26853 case INVALIDATE:
26854 case IS:
26855 case ISOLATION:
26856 case JAVA:
26857 case LEVEL:
26858 case LIKE:
26859 case LIMIT:
26860 case LIMITED:
26861 case LOCK:
26862 case LONG:
26863 case LOOP:
26864 case MAP:
26865 case MAX:
26866 case MEMBER:
26867 case MERGE:
26868 case MIN:
26869 case MINUS:
26870 case MINUTE:
26871 case MLSLABEL:
26872 case MODIFY:
26873 case MOD:
26874 case MODE:
26875 case MONTH:
26876 case NATURAL:
26877 case NATURALN:
26878 case NEW:
26879 case NEXTVAL:
26880 case NO:
26881 case NOCOPY:
26882 case NONEDITIONABLE:
26883 case NOT:
26884 case NOWAIT:
26885 case NULL:
26886 case NULLIF:
26887 case NUMBER:
26888 case BFILE_BASE:
26889 case BLOB_BASE:
26890 case CLOB_BASE:
26891 case DATE_BASE:
26892 case NUMBER_BASE:
26893 case OBJECT:
26894 case OCIROWID:
26895 case OF:
26896 case OID:
26897 case ON:
26898 case OPAQUE:
26899 case OPEN:
26900 case OPERATOR:
26901 case OPTION:
26902 case OR:
26903 case ORDER:
26904 case ORGANIZATION:
26905 case OTHERS:
26906 case OUT:
26907 case OVERRIDING:
26908 case PACKAGE:
26909 case PARTITION:
26910 case PCTFREE:
26911 case PLS_INTEGER:
26912 case POSITIVE:
26913 case POSITIVEN:
26914 case PRESERVE:
26915 case PRIOR:
26916 case PROMPT:
26917 case PRIVATE:
26918 case PROCEDURE:
26919 case PUBLIC:
26920 case RAISE:
26921 case RANGE:
26922 case RAW:
26923 case REAL:
26924 case RECORD:
26925 case REF:
26926 case RELEASE:
26927 case RELIES_ON:
26928 case RENAME:
26929 case RESULT:
26930 case RETURN:
26931 case RETURNING:
26932 case REVERSE:
26933 case ROLLBACK:
26934 case ROW:
26935 case ROWS:
26936 case ROWID:
26937 case ROWNUM:
26938 case ROWTYPE:
26939 case SAVE:
26940 case SAVEPOINT:
26941 case SECOND:
26942 case SELECT:
26943 case SELF:
26944 case SEPARATE:
26945 case SET:
26946 case SHARE:
26947 case SMALLINT:
26948 case SPACE:
26949 case SQL:
26950 case SQLCODE:
26951 case SQLERRM:
26952 case START:
26953 case STATIC:
26954 case STDDEV:
26955 case SUBTYPE:
26956 case SUBSTITUTABLE:
26957 case SUCCESSFUL:
26958 case SUM:
26959 case SYNONYM:
26960 case SYSDATE:
26961 case SYS_REFCURSOR:
26962 case TABLE:
26963 case TEMPORARY:
26964 case THEN:
26965 case TIME:
26966 case TIMESTAMP:
26967 case TIMEZONE_REGION:
26968 case TIMEZONE_ABBR:
26969 case TIMEZONE_MINUTE:
26970 case TIMEZONE_HOUR:
26971 case TO:
26972 case TRANSACTION:
26973 case TRIGGER:
26974 case TRUE:
26975 case TYPE:
26976 case UI:
26977 case UNDER:
26978 case USING:
26979 case WHILE:
26980 case YES:
26981 case SHOW:
26982 case A:
26983 case UPDATE:
26984 case VARCHAR:
26985 case VARCHAR2:
26986 case DOUBLE:
26987 case DEC:
26988 case PRECISION:
26989 case INT:
26990 case NUMERIC:
26991 case SIGNTYPE:
26992 case NCHAR:
26993 case NVARCHAR2:
26994 case STRING:
26995 case UROWID:
26996 case VARRAY:
26997 case VARYING:
26998 case BFILE:
26999 case BLOB:
27000 case CLOB:
27001 case NCLOB:
27002 case YEAR:
27003 case LOCAL:
27004 case WITH:
27005 case ZONE:
27006 case CHARACTER:
27007 case AFTER:
27008 case BEFORE:
27009 case OLD:
27010 case PARENT:
27011 case ANALYZE:
27012 case ASSOCIATE:
27013 case AUDIT:
27014 case COMPOUND:
27015 case DATABASE:
27016 case CALL:
27017 case DDL:
27018 case DISASSOCIATE:
27019 case EACH:
27020 case FOLLOWS:
27021 case LOGOFF:
27022 case LOGON:
27023 case NESTED:
27024 case NOAUDIT:
27025 case SCHEMA:
27026 case SERVERERROR:
27027 case SHUTDOWN:
27028 case STARTUP:
27029 case STATEMENT:
27030 case STATISTICS:
27031 case SUSPEND:
27032 case TRUNCATE:
27033 case WRAPPED:
27034 case LIBRARY:
27035 case NAME:
27036 case STRUCT:
27037 case CONTEXT:
27038 case PARAMETERS:
27039 case LENGTH:
27040 case TDO:
27041 case MAXLEN:
27042 case CHARSETID:
27043 case CHARSETFORM:
27044 case ACCEPT:
27045 case ACCESSIBLE:
27046 case COPY:
27047 case DEFINE:
27048 case DISCONNECT:
27049 case HOST:
27050 case PRINT:
27051 case QUIT:
27052 case REMARK:
27053 case UNDEFINE:
27054 case VARIABLE:
27055 case WHENEVER:
27056 case ATTACH:
27057 case CAST:
27058 case TREAT:
27059 case TRIM:
27060 case LEFT:
27061 case RIGHT:
27062 case BOTH:
27063 case EMPTY:
27064 case MULTISET:
27065 case SUBMULTISET:
27066 case LEADING:
27067 case TRAILING:
27068 case CHAR_CS:
27069 case NCHAR_CS:
27070 case DBTIMEZONE:
27071 case SESSIONTIMEZONE:
27072 case AUTHENTICATED:
27073 case LINK:
27074 case SHARED:
27075 case DIRECTORY:
27076 case USER:
27077 case IDENTIFIER:
27078 case QUOTED_LITERAL:
27079 case SQLDATA_CLASS:
27080 case CUSTOMDATUM_CLASS:
27081 case ORADATA_CLASS:
27082 case JAVA_INTERFACE_CLASS:
27083 ID();
27084 break;
27085 case STRING_LITERAL:
27086 StringLiteral();
27087 break;
27088 default:
27089 jj_la1[401] = jj_gen;
27090 jj_consume_token(-1);
27091 throw new ParseException();
27092 }
27093 switch (jj_nt.kind) {
27094 case 6:
27095 ;
27096 break;
27097 default:
27098 jj_la1[402] = jj_gen;
27099 break label_94;
27100 }
27101 }
27102 jj_consume_token(7);
27103 break;
27104 case EXCEPTION_INIT:
27105 jj_consume_token(EXCEPTION_INIT);
27106 jj_consume_token(5);
27107 jj_consume_token(IDENTIFIER);
27108 jj_consume_token(6);
27109 switch (jj_nt.kind) {
27110 case 16:
27111 case 17:
27112 switch (jj_nt.kind) {
27113 case 16:
27114 jj_consume_token(16);
27115 break;
27116 case 17:
27117 jj_consume_token(17);
27118 break;
27119 default:
27120 jj_la1[403] = jj_gen;
27121 jj_consume_token(-1);
27122 throw new ParseException();
27123 }
27124 break;
27125 default:
27126 jj_la1[404] = jj_gen;
27127 ;
27128 }
27129 NumericLiteral();
27130 jj_consume_token(7);
27131 break;
27132 case INTERFACE:
27133 jj_consume_token(INTERFACE);
27134 jj_consume_token(5);
27135 jj_consume_token(IDENTIFIER);
27136 jj_consume_token(6);
27137 jj_consume_token(IDENTIFIER);
27138 jj_consume_token(6);
27139 NumericLiteral();
27140 jj_consume_token(7);
27141 break;
27142 default:
27143 jj_la1[405] = jj_gen;
27144 jj_consume_token(-1);
27145 throw new ParseException();
27146 }
27147 jjtree.closeNodeScope(jjtn000, true);
27148 jjtc000 = false;
27149 {if (true) return jjtn000 ;}
27150 } catch (Throwable jjte000) {
27151 if (jjtc000) {
27152 jjtree.clearNodeScope(jjtn000);
27153 jjtc000 = false;
27154 } else {
27155 jjtree.popNode();
27156 }
27157 if (jjte000 instanceof RuntimeException) {
27158 {if (true) throw (RuntimeException)jjte000;}
27159 }
27160 if (jjte000 instanceof ParseException) {
27161 {if (true) throw (ParseException)jjte000;}
27162 }
27163 {if (true) throw (Error)jjte000;}
27164 } finally {
27165 if (jjtc000) {
27166 jjtree.closeNodeScope(jjtn000, true);
27167 }
27168 }
27169 throw new Error("Missing return statement in function");
27170 }
27171
27172
27173
27174
27175
27176
27177
27178
27179
27180
27181
27182
27183
27184
27185
27186
27187
27188
27189
27190
27191
27192
27193
27194
27195
27196
27197
27198
27199
27200
27201
27202
27203
27204
27205
27206
27207
27208
27209
27210
27211
27212
27213
27214
27215
27216
27217
27218
27219
27220
27221
27222
27223
27224
27225
27226
27227
27228
27229
27230
27231
27232
27233
27234
27235
27236
27237
27238
27239
27240
27241
27242
27243
27244
27245
27246 final public ASTTriggerUnit TriggerUnit() throws ParseException {
27247
27248 ASTTriggerUnit jjtn000 = new ASTTriggerUnit(this, JJTTRIGGERUNIT);
27249 boolean jjtc000 = true;
27250 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
27251 try {
27252 switch (jj_nt.kind) {
27253 case CREATE:
27254 jj_consume_token(CREATE);
27255 switch (jj_nt.kind) {
27256 case OR:
27257 jj_consume_token(OR);
27258 jj_consume_token(REPLACE);
27259 break;
27260 default:
27261 jj_la1[406] = jj_gen;
27262 ;
27263 }
27264 switch (jj_nt.kind) {
27265 case EDITIONABLE:
27266 case NONEDITIONABLE:
27267 switch (jj_nt.kind) {
27268 case EDITIONABLE:
27269 jj_consume_token(EDITIONABLE);
27270 break;
27271 case NONEDITIONABLE:
27272 jj_consume_token(NONEDITIONABLE);
27273 break;
27274 default:
27275 jj_la1[407] = jj_gen;
27276 jj_consume_token(-1);
27277 throw new ParseException();
27278 }
27279 break;
27280 default:
27281 jj_la1[408] = jj_gen;
27282 ;
27283 }
27284 break;
27285 default:
27286 jj_la1[409] = jj_gen;
27287 ;
27288 }
27289 jj_consume_token(TRIGGER);
27290 simpleNode = ObjectNameDeclaration();
27291 switch (jj_nt.kind) {
27292 case BEFORE:
27293 jj_consume_token(BEFORE);
27294 break;
27295 case AFTER:
27296 jj_consume_token(AFTER);
27297 break;
27298 case INSTEADOF:
27299 jj_consume_token(INSTEADOF);
27300 break;
27301 case FOR:
27302 jj_consume_token(FOR);
27303 break;
27304 default:
27305 jj_la1[410] = jj_gen;
27306 jj_consume_token(-1);
27307 throw new ParseException();
27308 }
27309 switch (jj_nt.kind) {
27310 case DELETE:
27311 case INSERT:
27312 case UPDATE:
27313 switch (jj_nt.kind) {
27314 case DELETE:
27315 jj_consume_token(DELETE);
27316 break;
27317 case INSERT:
27318 jj_consume_token(INSERT);
27319 break;
27320 case UPDATE:
27321 jj_consume_token(UPDATE);
27322 break;
27323 default:
27324 jj_la1[411] = jj_gen;
27325 jj_consume_token(-1);
27326 throw new ParseException();
27327 }
27328 if (jj_2_73(6)) {
27329 jj_consume_token(OF);
27330 ID();
27331 label_95:
27332 while (true) {
27333 switch (jj_nt.kind) {
27334 case 6:
27335 ;
27336 break;
27337 default:
27338 jj_la1[412] = jj_gen;
27339 break label_95;
27340 }
27341 jj_consume_token(6);
27342 ID();
27343 }
27344 } else {
27345 ;
27346 }
27347 break;
27348 case ALTER:
27349 case COMMENT:
27350 case CREATE:
27351 case DROP:
27352 case GRANT:
27353 case RENAME:
27354 case REVOKE:
27355 case ANALYZE:
27356 case ASSOCIATE:
27357 case AUDIT:
27358 case DDL:
27359 case DISASSOCIATE:
27360 case LOGOFF:
27361 case LOGON:
27362 case NOAUDIT:
27363 case SERVERERROR:
27364 case SHUTDOWN:
27365 case STARTUP:
27366 case SUSPEND:
27367 case TRUNCATE:
27368 NonDMLEvent();
27369 break;
27370 default:
27371 jj_la1[413] = jj_gen;
27372 jj_consume_token(-1);
27373 throw new ParseException();
27374 }
27375 label_96:
27376 while (true) {
27377 switch (jj_nt.kind) {
27378 case OR:
27379 ;
27380 break;
27381 default:
27382 jj_la1[414] = jj_gen;
27383 break label_96;
27384 }
27385 jj_consume_token(OR);
27386 switch (jj_nt.kind) {
27387 case DELETE:
27388 case INSERT:
27389 case UPDATE:
27390 switch (jj_nt.kind) {
27391 case DELETE:
27392 jj_consume_token(DELETE);
27393 break;
27394 case INSERT:
27395 jj_consume_token(INSERT);
27396 break;
27397 case UPDATE:
27398 jj_consume_token(UPDATE);
27399 break;
27400 default:
27401 jj_la1[415] = jj_gen;
27402 jj_consume_token(-1);
27403 throw new ParseException();
27404 }
27405 if (jj_2_74(6)) {
27406 jj_consume_token(OF);
27407 ID();
27408 label_97:
27409 while (true) {
27410 switch (jj_nt.kind) {
27411 case 6:
27412 ;
27413 break;
27414 default:
27415 jj_la1[416] = jj_gen;
27416 break label_97;
27417 }
27418 jj_consume_token(6);
27419 ID();
27420 }
27421 } else {
27422 ;
27423 }
27424 break;
27425 case ALTER:
27426 case COMMENT:
27427 case CREATE:
27428 case DROP:
27429 case GRANT:
27430 case RENAME:
27431 case REVOKE:
27432 case ANALYZE:
27433 case ASSOCIATE:
27434 case AUDIT:
27435 case DDL:
27436 case DISASSOCIATE:
27437 case LOGOFF:
27438 case LOGON:
27439 case NOAUDIT:
27440 case SERVERERROR:
27441 case SHUTDOWN:
27442 case STARTUP:
27443 case SUSPEND:
27444 case TRUNCATE:
27445 NonDMLEvent();
27446 break;
27447 default:
27448 jj_la1[417] = jj_gen;
27449 jj_consume_token(-1);
27450 throw new ParseException();
27451 }
27452 }
27453 jj_consume_token(ON);
27454 switch (jj_nt.kind) {
27455 case DATABASE:
27456 jj_consume_token(DATABASE);
27457 break;
27458 default:
27459 jj_la1[418] = jj_gen;
27460 if (jj_2_77(2)) {
27461 jj_consume_token(NESTED);
27462 jj_consume_token(TABLE);
27463 ID();
27464 jj_consume_token(OF);
27465 if (jj_2_75(2)) {
27466 ID();
27467 jj_consume_token(3);
27468 } else {
27469 ;
27470 }
27471 ID();
27472 } else {
27473 switch (jj_nt.kind) {
27474 case REPLACE:
27475 case DEFINER:
27476 case CURRENT_USER:
27477 case SERIALLY_REUSABLE:
27478 case RESTRICT_REFERENCES:
27479 case EXCEPTION_INIT:
27480 case AUTONOMOUS_TRANSACTION:
27481 case LANGUAGE:
27482 case INLINE:
27483 case ADD:
27484 case AGGREGATE:
27485 case ALL:
27486 case ALTER:
27487 case AND:
27488 case ANY:
27489 case ARRAY:
27490 case AS:
27491 case ASC:
27492 case AT:
27493 case ATTRIBUTE:
27494 case AUTHID:
27495 case AVG:
27496 case BETWEEN:
27497 case BINARY_INTEGER:
27498 case BODY:
27499 case BOOLEAN:
27500 case BULK:
27501 case BY:
27502 case BYTE:
27503 case CASCADE:
27504 case CASE:
27505 case CHAR:
27506 case CHAR_BASE:
27507 case CHECK:
27508 case CLOSE:
27509 case CLUSTER:
27510 case COALESCE:
27511 case COLLECT:
27512 case COLUMN:
27513 case COMMENT:
27514 case COMMIT:
27515 case COMPRESS:
27516 case CONNECT:
27517 case CONSTANT:
27518 case CONSTRUCTOR:
27519 case CONTINUE:
27520 case CONVERT:
27521 case CREATE:
27522 case CURRENT:
27523 case CURRVAL:
27524 case CURSOR:
27525 case DATA:
27526 case DATE:
27527 case DAY:
27528 case DECLARE:
27529 case DECIMAL:
27530 case _DEFAULT:
27531 case DELETE:
27532 case DESC:
27533 case DISABLE:
27534 case DISTINCT:
27535 case DO:
27536 case DROP:
27537 case EDITIONABLE:
27538 case ELEMENT:
27539 case ELSE:
27540 case ELSIF:
27541 case ENABLE:
27542 case ESCAPE:
27543 case EXCEPT:
27544 case EXCEPTION:
27545 case EXCEPTIONS:
27546 case EXCLUSIVE:
27547 case EXECUTE:
27548 case EXISTS:
27549 case EXIT:
27550 case EXTERNAL:
27551 case EXTENDS:
27552 case EXTRACT:
27553 case FALSE:
27554 case FETCH:
27555 case FINAL:
27556 case FLOAT:
27557 case FOR:
27558 case FORALL:
27559 case FORCE:
27560 case FROM:
27561 case FUNCTION:
27562 case GLOBAL:
27563 case GOTO:
27564 case GROUP:
27565 case HASH:
27566 case HAVING:
27567 case HEAP:
27568 case HOUR:
27569 case IF:
27570 case IMMEDIATE:
27571 case IN:
27572 case INDEX:
27573 case INDICES:
27574 case INDEXTYPE:
27575 case INDICATOR:
27576 case INSERT:
27577 case INSTANTIABLE:
27578 case INTEGER:
27579 case INTERFACE:
27580 case INTERSECT:
27581 case INTERVAL:
27582 case INTO:
27583 case INVALIDATE:
27584 case IS:
27585 case ISOLATION:
27586 case JAVA:
27587 case LEVEL:
27588 case LIKE:
27589 case LIMIT:
27590 case LIMITED:
27591 case LOCK:
27592 case LONG:
27593 case LOOP:
27594 case MAP:
27595 case MAX:
27596 case MEMBER:
27597 case MERGE:
27598 case MIN:
27599 case MINUS:
27600 case MINUTE:
27601 case MLSLABEL:
27602 case MODIFY:
27603 case MOD:
27604 case MODE:
27605 case MONTH:
27606 case NATURAL:
27607 case NATURALN:
27608 case NEW:
27609 case NEXTVAL:
27610 case NO:
27611 case NOCOPY:
27612 case NONEDITIONABLE:
27613 case NOT:
27614 case NOWAIT:
27615 case NULL:
27616 case NULLIF:
27617 case NUMBER:
27618 case BFILE_BASE:
27619 case BLOB_BASE:
27620 case CLOB_BASE:
27621 case DATE_BASE:
27622 case NUMBER_BASE:
27623 case OBJECT:
27624 case OCIROWID:
27625 case OF:
27626 case OID:
27627 case ON:
27628 case OPAQUE:
27629 case OPEN:
27630 case OPERATOR:
27631 case OPTION:
27632 case OR:
27633 case ORDER:
27634 case ORGANIZATION:
27635 case OTHERS:
27636 case OUT:
27637 case OVERRIDING:
27638 case PACKAGE:
27639 case PARTITION:
27640 case PCTFREE:
27641 case PLS_INTEGER:
27642 case POSITIVE:
27643 case POSITIVEN:
27644 case PRESERVE:
27645 case PRIOR:
27646 case PROMPT:
27647 case PRIVATE:
27648 case PROCEDURE:
27649 case PUBLIC:
27650 case RAISE:
27651 case RANGE:
27652 case RAW:
27653 case REAL:
27654 case RECORD:
27655 case REF:
27656 case RELEASE:
27657 case RELIES_ON:
27658 case RENAME:
27659 case RESULT:
27660 case RETURN:
27661 case RETURNING:
27662 case REVERSE:
27663 case ROLLBACK:
27664 case ROW:
27665 case ROWS:
27666 case ROWID:
27667 case ROWNUM:
27668 case ROWTYPE:
27669 case SAVE:
27670 case SAVEPOINT:
27671 case SECOND:
27672 case SELECT:
27673 case SELF:
27674 case SEPARATE:
27675 case SET:
27676 case SHARE:
27677 case SMALLINT:
27678 case SPACE:
27679 case SQL:
27680 case SQLCODE:
27681 case SQLERRM:
27682 case START:
27683 case STATIC:
27684 case STDDEV:
27685 case SUBTYPE:
27686 case SUBSTITUTABLE:
27687 case SUCCESSFUL:
27688 case SUM:
27689 case SYNONYM:
27690 case SYSDATE:
27691 case SYS_REFCURSOR:
27692 case TABLE:
27693 case TEMPORARY:
27694 case THEN:
27695 case TIME:
27696 case TIMESTAMP:
27697 case TIMEZONE_REGION:
27698 case TIMEZONE_ABBR:
27699 case TIMEZONE_MINUTE:
27700 case TIMEZONE_HOUR:
27701 case TO:
27702 case TRANSACTION:
27703 case TRIGGER:
27704 case TRUE:
27705 case TYPE:
27706 case UI:
27707 case UNDER:
27708 case USING:
27709 case WHILE:
27710 case YES:
27711 case SHOW:
27712 case A:
27713 case UPDATE:
27714 case VARCHAR:
27715 case VARCHAR2:
27716 case DOUBLE:
27717 case DEC:
27718 case PRECISION:
27719 case INT:
27720 case NUMERIC:
27721 case SIGNTYPE:
27722 case NCHAR:
27723 case NVARCHAR2:
27724 case STRING:
27725 case UROWID:
27726 case VARRAY:
27727 case VARYING:
27728 case BFILE:
27729 case BLOB:
27730 case CLOB:
27731 case NCLOB:
27732 case YEAR:
27733 case LOCAL:
27734 case WITH:
27735 case ZONE:
27736 case CHARACTER:
27737 case AFTER:
27738 case BEFORE:
27739 case OLD:
27740 case PARENT:
27741 case ANALYZE:
27742 case ASSOCIATE:
27743 case AUDIT:
27744 case COMPOUND:
27745 case DATABASE:
27746 case CALL:
27747 case DDL:
27748 case DISASSOCIATE:
27749 case EACH:
27750 case FOLLOWS:
27751 case LOGOFF:
27752 case LOGON:
27753 case NESTED:
27754 case NOAUDIT:
27755 case SCHEMA:
27756 case SERVERERROR:
27757 case SHUTDOWN:
27758 case STARTUP:
27759 case STATEMENT:
27760 case STATISTICS:
27761 case SUSPEND:
27762 case TRUNCATE:
27763 case WRAPPED:
27764 case LIBRARY:
27765 case NAME:
27766 case STRUCT:
27767 case CONTEXT:
27768 case PARAMETERS:
27769 case LENGTH:
27770 case TDO:
27771 case MAXLEN:
27772 case CHARSETID:
27773 case CHARSETFORM:
27774 case ACCEPT:
27775 case ACCESSIBLE:
27776 case COPY:
27777 case DEFINE:
27778 case DISCONNECT:
27779 case HOST:
27780 case PRINT:
27781 case QUIT:
27782 case REMARK:
27783 case UNDEFINE:
27784 case VARIABLE:
27785 case WHENEVER:
27786 case ATTACH:
27787 case CAST:
27788 case TREAT:
27789 case TRIM:
27790 case LEFT:
27791 case RIGHT:
27792 case BOTH:
27793 case EMPTY:
27794 case MULTISET:
27795 case SUBMULTISET:
27796 case LEADING:
27797 case TRAILING:
27798 case CHAR_CS:
27799 case NCHAR_CS:
27800 case DBTIMEZONE:
27801 case SESSIONTIMEZONE:
27802 case AUTHENTICATED:
27803 case LINK:
27804 case SHARED:
27805 case DIRECTORY:
27806 case USER:
27807 case IDENTIFIER:
27808 case QUOTED_LITERAL:
27809 case SQLDATA_CLASS:
27810 case CUSTOMDATUM_CLASS:
27811 case ORADATA_CLASS:
27812 case JAVA_INTERFACE_CLASS:
27813 if (jj_2_76(2)) {
27814 ID();
27815 jj_consume_token(3);
27816 } else {
27817 ;
27818 }
27819 ID();
27820 break;
27821 default:
27822 jj_la1[419] = jj_gen;
27823 jj_consume_token(-1);
27824 throw new ParseException();
27825 }
27826 }
27827 }
27828 switch (jj_nt.kind) {
27829 case REFERENCING:
27830 jj_consume_token(REFERENCING);
27831 label_98:
27832 while (true) {
27833 switch (jj_nt.kind) {
27834 case NEW:
27835 case OLD:
27836 case PARENT:
27837 ;
27838 break;
27839 default:
27840 jj_la1[420] = jj_gen;
27841 break label_98;
27842 }
27843 switch (jj_nt.kind) {
27844 case OLD:
27845 jj_consume_token(OLD);
27846 break;
27847 case NEW:
27848 jj_consume_token(NEW);
27849 break;
27850 case PARENT:
27851 jj_consume_token(PARENT);
27852 break;
27853 default:
27854 jj_la1[421] = jj_gen;
27855 jj_consume_token(-1);
27856 throw new ParseException();
27857 }
27858 jj_consume_token(AS);
27859 ID();
27860 }
27861 break;
27862 default:
27863 jj_la1[422] = jj_gen;
27864 ;
27865 }
27866 switch (jj_nt.kind) {
27867 case FOREACHROW:
27868 jj_consume_token(FOREACHROW);
27869 break;
27870 default:
27871 jj_la1[423] = jj_gen;
27872 ;
27873 }
27874 switch (jj_nt.kind) {
27875 case REVERSE:
27876 case FORWARD:
27877 case CROSSEDITION:
27878 switch (jj_nt.kind) {
27879 case REVERSE:
27880 case FORWARD:
27881 switch (jj_nt.kind) {
27882 case FORWARD:
27883 jj_consume_token(FORWARD);
27884 break;
27885 case REVERSE:
27886 jj_consume_token(REVERSE);
27887 break;
27888 default:
27889 jj_la1[424] = jj_gen;
27890 jj_consume_token(-1);
27891 throw new ParseException();
27892 }
27893 break;
27894 default:
27895 jj_la1[425] = jj_gen;
27896 ;
27897 }
27898 jj_consume_token(CROSSEDITION);
27899 break;
27900 default:
27901 jj_la1[426] = jj_gen;
27902 ;
27903 }
27904 switch (jj_nt.kind) {
27905 case FOLLOWS:
27906 case PRECEDES:
27907 switch (jj_nt.kind) {
27908 case FOLLOWS:
27909 jj_consume_token(FOLLOWS);
27910 break;
27911 case PRECEDES:
27912 jj_consume_token(PRECEDES);
27913 break;
27914 default:
27915 jj_la1[427] = jj_gen;
27916 jj_consume_token(-1);
27917 throw new ParseException();
27918 }
27919 if (jj_2_78(2)) {
27920 ID();
27921 jj_consume_token(3);
27922 } else {
27923 ;
27924 }
27925 ID();
27926 label_99:
27927 while (true) {
27928 switch (jj_nt.kind) {
27929 case 6:
27930 ;
27931 break;
27932 default:
27933 jj_la1[428] = jj_gen;
27934 break label_99;
27935 }
27936 jj_consume_token(6);
27937 if (jj_2_79(2)) {
27938 ID();
27939 jj_consume_token(3);
27940 } else {
27941 ;
27942 }
27943 ID();
27944 }
27945 break;
27946 default:
27947 jj_la1[429] = jj_gen;
27948 ;
27949 }
27950 switch (jj_nt.kind) {
27951 case DISABLE:
27952 case ENABLE:
27953 switch (jj_nt.kind) {
27954 case ENABLE:
27955 jj_consume_token(ENABLE);
27956 break;
27957 case DISABLE:
27958 jj_consume_token(DISABLE);
27959 break;
27960 default:
27961 jj_la1[430] = jj_gen;
27962 jj_consume_token(-1);
27963 throw new ParseException();
27964 }
27965 break;
27966 default:
27967 jj_la1[431] = jj_gen;
27968 ;
27969 }
27970 switch (jj_nt.kind) {
27971 case WHEN:
27972 jj_consume_token(WHEN);
27973 jj_consume_token(5);
27974 ConditionalOrExpression();
27975 jj_consume_token(7);
27976 break;
27977 default:
27978 jj_la1[432] = jj_gen;
27979 ;
27980 }
27981 switch (jj_nt.kind) {
27982 case CALL:
27983 jj_consume_token(CALL);
27984 PrimaryExpression();
27985 jj_consume_token(4);
27986 break;
27987 case COMPOUND:
27988 CompoundTriggerBlock();
27989 break;
27990 case BEGIN:
27991 case DECLARE:
27992 Block();
27993 jj_consume_token(4);
27994 break;
27995 default:
27996 jj_la1[433] = jj_gen;
27997 jj_consume_token(-1);
27998 throw new ParseException();
27999 }
28000 jjtree.closeNodeScope(jjtn000, true);
28001 jjtc000 = false;
28002 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
28003 } catch (Throwable jjte000) {
28004 if (jjtc000) {
28005 jjtree.clearNodeScope(jjtn000);
28006 jjtc000 = false;
28007 } else {
28008 jjtree.popNode();
28009 }
28010 if (jjte000 instanceof RuntimeException) {
28011 {if (true) throw (RuntimeException)jjte000;}
28012 }
28013 if (jjte000 instanceof ParseException) {
28014 {if (true) throw (ParseException)jjte000;}
28015 }
28016 {if (true) throw (Error)jjte000;}
28017 } finally {
28018 if (jjtc000) {
28019 jjtree.closeNodeScope(jjtn000, true);
28020 }
28021 }
28022 throw new Error("Missing return statement in function");
28023 }
28024
28025 final public ASTTriggerTimingPointSection TriggerTimingPointSection() throws ParseException {
28026
28027 ASTTriggerTimingPointSection jjtn000 = new ASTTriggerTimingPointSection(this, JJTTRIGGERTIMINGPOINTSECTION);
28028 boolean jjtc000 = true;
28029 jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
28030 try {
28031 switch (jj_nt.kind) {
28032 case BEFORE:
28033 jj_consume_token(BEFORE);
28034 break;
28035 case AFTER:
28036 jj_consume_token(AFTER);
28037 break;
28038 case INSTEADOF:
28039 jj_consume_token(INSTEADOF);
28040 break;
28041 default:
28042 jj_la1[434] = jj_gen;
28043 jj_consume_token(-1);
28044 throw new ParseException();
28045 }
28046 sb.append(token.image) ;
28047 switch (jj_nt.kind) {
28048 case STATEMENT:
28049 jj_consume_token(STATEMENT);
28050 break;
28051 case EACH:
28052 jj_consume_token(EACH);
28053 jj_consume_token(ROW);
28054 break;
28055 default:
28056 jj_la1[435] = jj_gen;
28057 jj_consume_token(-1);
28058 throw new ParseException();
28059 }
28060 sb.append(" "); sb.append(token.image) ;
28061 jj_consume_token(IS);
28062 jj_consume_token(BEGIN);
28063 label_100:
28064 while (true) {
28065 Statement();
28066 switch (jj_nt.kind) {
28067 case 5:
28068 case 16:
28069 case 17:
28070 case 21:
28071 case REPLACE:
28072 case DEFINER:
28073 case CURRENT_USER:
28074 case LANGUAGE:
28075 case INLINE:
28076 case ADD:
28077 case AGGREGATE:
28078 case ARRAY:
28079 case AT:
28080 case ATTRIBUTE:
28081 case AUTHID:
28082 case BEGIN:
28083 case BODY:
28084 case BULK:
28085 case BYTE:
28086 case CASCADE:
28087 case CASE:
28088 case CLOSE:
28089 case COALESCE:
28090 case COLLECT:
28091 case COLUMN:
28092 case COMMENT:
28093 case COMMIT:
28094 case CONSTRUCTOR:
28095 case CONTINUE:
28096 case CONVERT:
28097 case CURRENT:
28098 case CURSOR:
28099 case DATA:
28100 case DATE:
28101 case DAY:
28102 case DECLARE:
28103 case DELETE:
28104 case DISABLE:
28105 case EDITIONABLE:
28106 case ELEMENT:
28107 case ENABLE:
28108 case ESCAPE:
28109 case EXCEPT:
28110 case EXCEPTIONS:
28111 case EXECUTE:
28112 case EXIT:
28113 case EXTERNAL:
28114 case EXTENDS:
28115 case EXTRACT:
28116 case FALSE:
28117 case FETCH:
28118 case FINAL:
28119 case FOR:
28120 case FORALL:
28121 case FORCE:
28122 case FUNCTION:
28123 case GLOBAL:
28124 case GOTO:
28125 case HASH:
28126 case HEAP:
28127 case HOUR:
28128 case IF:
28129 case IMMEDIATE:
28130 case INDICES:
28131 case INDEXTYPE:
28132 case INDICATOR:
28133 case INSERT:
28134 case INSTANTIABLE:
28135 case INTERVAL:
28136 case INVALIDATE:
28137 case ISOLATION:
28138 case JAVA:
28139 case LEVEL:
28140 case LIMIT:
28141 case LOCK:
28142 case LOOP:
28143 case MAP:
28144 case MAX:
28145 case MEMBER:
28146 case MERGE:
28147 case MIN:
28148 case MINUTE:
28149 case MLSLABEL:
28150 case MODIFY:
28151 case MOD:
28152 case MONTH:
28153 case NATURAL:
28154 case NEW:
28155 case NEW_DOT:
28156 case NO:
28157 case NONEDITIONABLE:
28158 case NOT:
28159 case NULL:
28160 case NULLIF:
28161 case OBJECT:
28162 case OID:
28163 case OPAQUE:
28164 case OPEN:
28165 case OPERATOR:
28166 case ORGANIZATION:
28167 case OTHERS:
28168 case OVERRIDING:
28169 case PACKAGE:
28170 case PARTITION:
28171 case PIPE:
28172 case PRAGMA:
28173 case PRESERVE:
28174 case PRIVATE:
28175 case PROCEDURE:
28176 case RAISE:
28177 case RANGE:
28178 case RAW:
28179 case REAL:
28180 case RECORD:
28181 case REF:
28182 case RELEASE:
28183 case RELIES_ON:
28184 case RENAME:
28185 case RESULT:
28186 case RETURN:
28187 case RETURNING:
28188 case REVERSE:
28189 case ROLLBACK:
28190 case ROW:
28191 case ROWS:
28192 case ROWID:
28193 case ROWNUM:
28194 case SAVE:
28195 case SAVEPOINT:
28196 case SECOND:
28197 case SELECT:
28198 case SELF:
28199 case SET:
28200 case SPACE:
28201 case SQL:
28202 case SQLCODE:
28203 case SQLERRM:
28204 case STATIC:
28205 case SUBTYPE:
28206 case SUBSTITUTABLE:
28207 case SUCCESSFUL:
28208 case SYSDATE:
28209 case SYS_REFCURSOR:
28210 case TEMPORARY:
28211 case TIME:
28212 case TIMESTAMP:
28213 case TIMEZONE_REGION:
28214 case TIMEZONE_ABBR:
28215 case TIMEZONE_MINUTE:
28216 case TIMEZONE_HOUR:
28217 case TRANSACTION:
28218 case TRUE:
28219 case TYPE:
28220 case UNDER:
28221 case USING:
28222 case WHILE:
28223 case YES:
28224 case SHOW:
28225 case A:
28226 case UPDATE:
28227 case DOUBLE:
28228 case DEC:
28229 case PRECISION:
28230 case INT:
28231 case NUMERIC:
28232 case NCHAR:
28233 case NVARCHAR2:
28234 case STRING:
28235 case UROWID:
28236 case VARRAY:
28237 case VARYING:
28238 case BFILE:
28239 case BLOB:
28240 case CLOB:
28241 case NCLOB:
28242 case YEAR:
28243 case LOCAL:
28244 case WITH:
28245 case ZONE:
28246 case CHARACTER:
28247 case AFTER:
28248 case BEFORE:
28249 case OLD:
28250 case PARENT:
28251 case CC_IF:
28252 case CC_ERROR:
28253 case ANALYZE:
28254 case ASSOCIATE:
28255 case AUDIT:
28256 case COMPOUND:
28257 case DATABASE:
28258 case CALL:
28259 case DDL:
28260 case DISASSOCIATE:
28261 case EACH:
28262 case FOLLOWS:
28263 case LOGOFF:
28264 case LOGON:
28265 case NESTED:
28266 case NOAUDIT:
28267 case SCHEMA:
28268 case SERVERERROR:
28269 case SHUTDOWN:
28270 case STARTUP:
28271 case STATEMENT:
28272 case STATISTICS:
28273 case SUSPEND:
28274 case TRUNCATE:
28275 case WRAPPED:
28276 case LIBRARY:
28277 case NAME:
28278 case STRUCT:
28279 case CONTEXT:
28280 case PARAMETERS:
28281 case LENGTH:
28282 case TDO:
28283 case MAXLEN:
28284 case CHARSETID:
28285 case CHARSETFORM:
28286 case ACCEPT:
28287 case ACCESSIBLE:
28288 case COPY:
28289 case DEFINE:
28290 case DISCONNECT:
28291 case HOST:
28292 case PRINT:
28293 case QUIT:
28294 case REMARK:
28295 case UNDEFINE:
28296 case VARIABLE:
28297 case WHENEVER:
28298 case ATTACH:
28299 case CAST:
28300 case TREAT:
28301 case TRIM:
28302 case LEFT:
28303 case RIGHT:
28304 case BOTH:
28305 case EMPTY:
28306 case MULTISET:
28307 case SUBMULTISET:
28308 case LEADING:
28309 case TRAILING:
28310 case CHAR_CS:
28311 case NCHAR_CS:
28312 case DBTIMEZONE:
28313 case SESSIONTIMEZONE:
28314 case AUTHENTICATED:
28315 case LINK:
28316 case SHARED:
28317 case DIRECTORY:
28318 case USER:
28319 case IDENTIFIER:
28320 case UNSIGNED_NUMERIC_LITERAL:
28321 case CHARACTER_LITERAL:
28322 case STRING_LITERAL:
28323 case QUOTED_LITERAL:
28324 ;
28325 break;
28326 default:
28327 jj_la1[436] = jj_gen;
28328 break label_100;
28329 }
28330 }
28331 jj_consume_token(END);
28332 switch (jj_nt.kind) {
28333 case BEFORE:
28334 jj_consume_token(BEFORE);
28335 break;
28336 case AFTER:
28337 jj_consume_token(AFTER);
28338 break;
28339 case INSTEADOF:
28340 jj_consume_token(INSTEADOF);
28341 break;
28342 default:
28343 jj_la1[437] = jj_gen;
28344 jj_consume_token(-1);
28345 throw new ParseException();
28346 }
28347 switch (jj_nt.kind) {
28348 case STATEMENT:
28349 jj_consume_token(STATEMENT);
28350 break;
28351 case EACH:
28352 jj_consume_token(EACH);
28353 jj_consume_token(ROW);
28354 break;
28355 default:
28356 jj_la1[438] = jj_gen;
28357 jj_consume_token(-1);
28358 throw new ParseException();
28359 }
28360 jj_consume_token(4);
28361
28362 jjtree.closeNodeScope(jjtn000, true);
28363 jjtc000 = false;
28364 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
28365 } catch (Throwable jjte000) {
28366 if (jjtc000) {
28367 jjtree.clearNodeScope(jjtn000);
28368 jjtc000 = false;
28369 } else {
28370 jjtree.popNode();
28371 }
28372 if (jjte000 instanceof RuntimeException) {
28373 {if (true) throw (RuntimeException)jjte000;}
28374 }
28375 if (jjte000 instanceof ParseException) {
28376 {if (true) throw (ParseException)jjte000;}
28377 }
28378 {if (true) throw (Error)jjte000;}
28379 } finally {
28380 if (jjtc000) {
28381 jjtree.closeNodeScope(jjtn000, true);
28382 }
28383 }
28384 throw new Error("Missing return statement in function");
28385 }
28386
28387 final public ASTCompoundTriggerBlock CompoundTriggerBlock() throws ParseException {
28388
28389 ASTCompoundTriggerBlock jjtn000 = new ASTCompoundTriggerBlock(this, JJTCOMPOUNDTRIGGERBLOCK);
28390 boolean jjtc000 = true;
28391 jjtree.openNodeScope(jjtn000);
28392 try {
28393 jj_consume_token(COMPOUND);
28394 jj_consume_token(TRIGGER);
28395 label_101:
28396 while (true) {
28397 switch (jj_nt.kind) {
28398 case REPLACE:
28399 case DEFINER:
28400 case CURRENT_USER:
28401 case SERIALLY_REUSABLE:
28402 case RESTRICT_REFERENCES:
28403 case EXCEPTION_INIT:
28404 case AUTONOMOUS_TRANSACTION:
28405 case LANGUAGE:
28406 case INLINE:
28407 case ADD:
28408 case AGGREGATE:
28409 case ALL:
28410 case ALTER:
28411 case AND:
28412 case ANY:
28413 case ARRAY:
28414 case AS:
28415 case ASC:
28416 case AT:
28417 case ATTRIBUTE:
28418 case AUTHID:
28419 case AVG:
28420 case BETWEEN:
28421 case BINARY_INTEGER:
28422 case BODY:
28423 case BOOLEAN:
28424 case BULK:
28425 case BY:
28426 case BYTE:
28427 case CASCADE:
28428 case CASE:
28429 case CHAR:
28430 case CHAR_BASE:
28431 case CHECK:
28432 case CLOSE:
28433 case CLUSTER:
28434 case COALESCE:
28435 case COLLECT:
28436 case COLUMN:
28437 case COMMENT:
28438 case COMMIT:
28439 case COMPRESS:
28440 case CONNECT:
28441 case CONSTANT:
28442 case CONSTRUCTOR:
28443 case CONTINUE:
28444 case CONVERT:
28445 case CREATE:
28446 case CURRENT:
28447 case CURRVAL:
28448 case CURSOR:
28449 case DATA:
28450 case DATE:
28451 case DAY:
28452 case DECLARE:
28453 case DECIMAL:
28454 case _DEFAULT:
28455 case DELETE:
28456 case DESC:
28457 case DISABLE:
28458 case DISTINCT:
28459 case DO:
28460 case DROP:
28461 case EDITIONABLE:
28462 case ELEMENT:
28463 case ELSE:
28464 case ELSIF:
28465 case ENABLE:
28466 case ESCAPE:
28467 case EXCEPT:
28468 case EXCEPTION:
28469 case EXCEPTIONS:
28470 case EXCLUSIVE:
28471 case EXECUTE:
28472 case EXISTS:
28473 case EXIT:
28474 case EXTERNAL:
28475 case EXTENDS:
28476 case EXTRACT:
28477 case FALSE:
28478 case FETCH:
28479 case FINAL:
28480 case FLOAT:
28481 case FOR:
28482 case FORALL:
28483 case FORCE:
28484 case FROM:
28485 case FUNCTION:
28486 case GLOBAL:
28487 case GOTO:
28488 case GROUP:
28489 case HASH:
28490 case HAVING:
28491 case HEAP:
28492 case HOUR:
28493 case IF:
28494 case IMMEDIATE:
28495 case IN:
28496 case INDEX:
28497 case INDICES:
28498 case INDEXTYPE:
28499 case INDICATOR:
28500 case INSERT:
28501 case INSTANTIABLE:
28502 case INTEGER:
28503 case INTERFACE:
28504 case INTERSECT:
28505 case INTERVAL:
28506 case INTO:
28507 case INVALIDATE:
28508 case IS:
28509 case ISOLATION:
28510 case JAVA:
28511 case LEVEL:
28512 case LIKE:
28513 case LIMIT:
28514 case LIMITED:
28515 case LOCK:
28516 case LONG:
28517 case LOOP:
28518 case MAP:
28519 case MAX:
28520 case MEMBER:
28521 case MERGE:
28522 case MIN:
28523 case MINUS:
28524 case MINUTE:
28525 case MLSLABEL:
28526 case MODIFY:
28527 case MOD:
28528 case MODE:
28529 case MONTH:
28530 case NATURAL:
28531 case NATURALN:
28532 case NEW:
28533 case NEXTVAL:
28534 case NO:
28535 case NOCOPY:
28536 case NONEDITIONABLE:
28537 case NOT:
28538 case NOWAIT:
28539 case NULL:
28540 case NULLIF:
28541 case NUMBER:
28542 case BFILE_BASE:
28543 case BLOB_BASE:
28544 case CLOB_BASE:
28545 case DATE_BASE:
28546 case NUMBER_BASE:
28547 case OBJECT:
28548 case OCIROWID:
28549 case OF:
28550 case OID:
28551 case ON:
28552 case OPAQUE:
28553 case OPEN:
28554 case OPERATOR:
28555 case OPTION:
28556 case OR:
28557 case ORDER:
28558 case ORGANIZATION:
28559 case OTHERS:
28560 case OUT:
28561 case OVERRIDING:
28562 case PACKAGE:
28563 case PARTITION:
28564 case PCTFREE:
28565 case PLS_INTEGER:
28566 case POSITIVE:
28567 case POSITIVEN:
28568 case PRAGMA:
28569 case PRESERVE:
28570 case PRIOR:
28571 case PROMPT:
28572 case PRIVATE:
28573 case PROCEDURE:
28574 case PUBLIC:
28575 case RAISE:
28576 case RANGE:
28577 case RAW:
28578 case REAL:
28579 case RECORD:
28580 case REF:
28581 case RELEASE:
28582 case RELIES_ON:
28583 case RENAME:
28584 case RESULT:
28585 case RETURN:
28586 case RETURNING:
28587 case REVERSE:
28588 case ROLLBACK:
28589 case ROW:
28590 case ROWS:
28591 case ROWID:
28592 case ROWNUM:
28593 case ROWTYPE:
28594 case SAVE:
28595 case SAVEPOINT:
28596 case SECOND:
28597 case SELECT:
28598 case SELF:
28599 case SEPARATE:
28600 case SET:
28601 case SHARE:
28602 case SMALLINT:
28603 case SPACE:
28604 case SQL:
28605 case SQLCODE:
28606 case SQLERRM:
28607 case START:
28608 case STATIC:
28609 case STDDEV:
28610 case SUBTYPE:
28611 case SUBSTITUTABLE:
28612 case SUCCESSFUL:
28613 case SUM:
28614 case SYNONYM:
28615 case SYSDATE:
28616 case SYS_REFCURSOR:
28617 case TABLE:
28618 case TEMPORARY:
28619 case THEN:
28620 case TIME:
28621 case TIMESTAMP:
28622 case TIMEZONE_REGION:
28623 case TIMEZONE_ABBR:
28624 case TIMEZONE_MINUTE:
28625 case TIMEZONE_HOUR:
28626 case TO:
28627 case TRANSACTION:
28628 case TRIGGER:
28629 case TRUE:
28630 case TYPE:
28631 case UI:
28632 case UNDER:
28633 case USING:
28634 case WHILE:
28635 case YES:
28636 case SHOW:
28637 case A:
28638 case UPDATE:
28639 case VARCHAR:
28640 case VARCHAR2:
28641 case DOUBLE:
28642 case DEC:
28643 case PRECISION:
28644 case INT:
28645 case NUMERIC:
28646 case SIGNTYPE:
28647 case NCHAR:
28648 case NVARCHAR2:
28649 case STRING:
28650 case UROWID:
28651 case VARRAY:
28652 case VARYING:
28653 case BFILE:
28654 case BLOB:
28655 case CLOB:
28656 case NCLOB:
28657 case YEAR:
28658 case LOCAL:
28659 case WITH:
28660 case ZONE:
28661 case CHARACTER:
28662 case AFTER:
28663 case BEFORE:
28664 case INSTEADOF:
28665 case OLD:
28666 case PARENT:
28667 case ANALYZE:
28668 case ASSOCIATE:
28669 case AUDIT:
28670 case COMPOUND:
28671 case DATABASE:
28672 case CALL:
28673 case DDL:
28674 case DISASSOCIATE:
28675 case EACH:
28676 case FOLLOWS:
28677 case LOGOFF:
28678 case LOGON:
28679 case NESTED:
28680 case NOAUDIT:
28681 case SCHEMA:
28682 case SERVERERROR:
28683 case SHUTDOWN:
28684 case STARTUP:
28685 case STATEMENT:
28686 case STATISTICS:
28687 case SUSPEND:
28688 case TRUNCATE:
28689 case WRAPPED:
28690 case LIBRARY:
28691 case NAME:
28692 case STRUCT:
28693 case CONTEXT:
28694 case PARAMETERS:
28695 case LENGTH:
28696 case TDO:
28697 case MAXLEN:
28698 case CHARSETID:
28699 case CHARSETFORM:
28700 case ACCEPT:
28701 case ACCESSIBLE:
28702 case COPY:
28703 case DEFINE:
28704 case DISCONNECT:
28705 case HOST:
28706 case PRINT:
28707 case QUIT:
28708 case REMARK:
28709 case UNDEFINE:
28710 case VARIABLE:
28711 case WHENEVER:
28712 case ATTACH:
28713 case CAST:
28714 case TREAT:
28715 case TRIM:
28716 case LEFT:
28717 case RIGHT:
28718 case BOTH:
28719 case EMPTY:
28720 case MULTISET:
28721 case SUBMULTISET:
28722 case LEADING:
28723 case TRAILING:
28724 case CHAR_CS:
28725 case NCHAR_CS:
28726 case DBTIMEZONE:
28727 case SESSIONTIMEZONE:
28728 case AUTHENTICATED:
28729 case LINK:
28730 case SHARED:
28731 case DIRECTORY:
28732 case USER:
28733 case IDENTIFIER:
28734 case QUOTED_LITERAL:
28735 case SQLDATA_CLASS:
28736 case CUSTOMDATUM_CLASS:
28737 case ORADATA_CLASS:
28738 case JAVA_INTERFACE_CLASS:
28739 ;
28740 break;
28741 default:
28742 jj_la1[439] = jj_gen;
28743 break label_101;
28744 }
28745 switch (jj_nt.kind) {
28746 case AFTER:
28747 case BEFORE:
28748 case INSTEADOF:
28749 TriggerTimingPointSection();
28750 break;
28751 case PRAGMA:
28752 Pragma();
28753 break;
28754 default:
28755 jj_la1[440] = jj_gen;
28756 if (jj_2_80(2)) {
28757 ExceptionDeclaration();
28758 } else if (jj_2_81(2)) {
28759 SubTypeDefinition();
28760 } else if (jj_2_82(4)) {
28761 VariableOrConstantDeclaration();
28762 } else if (jj_2_83(2)) {
28763 CursorSpecification();
28764 } else {
28765 switch (jj_nt.kind) {
28766 case CURSOR:
28767 CursorBody();
28768 break;
28769 case IDENTIFIER:
28770 CollectionDeclaration();
28771 break;
28772 case CREATE:
28773 case FUNCTION:
28774 case PROCEDURE:
28775 ProgramUnit();
28776 break;
28777 default:
28778 jj_la1[441] = jj_gen;
28779 jj_consume_token(-1);
28780 throw new ParseException();
28781 }
28782 }
28783 }
28784 }
28785 jj_consume_token(END);
28786 switch (jj_nt.kind) {
28787 case REPLACE:
28788 case DEFINER:
28789 case CURRENT_USER:
28790 case SERIALLY_REUSABLE:
28791 case RESTRICT_REFERENCES:
28792 case EXCEPTION_INIT:
28793 case AUTONOMOUS_TRANSACTION:
28794 case LANGUAGE:
28795 case INLINE:
28796 case ADD:
28797 case AGGREGATE:
28798 case ALL:
28799 case ALTER:
28800 case AND:
28801 case ANY:
28802 case ARRAY:
28803 case AS:
28804 case ASC:
28805 case AT:
28806 case ATTRIBUTE:
28807 case AUTHID:
28808 case AVG:
28809 case BETWEEN:
28810 case BINARY_INTEGER:
28811 case BODY:
28812 case BOOLEAN:
28813 case BULK:
28814 case BY:
28815 case BYTE:
28816 case CASCADE:
28817 case CASE:
28818 case CHAR:
28819 case CHAR_BASE:
28820 case CHECK:
28821 case CLOSE:
28822 case CLUSTER:
28823 case COALESCE:
28824 case COLLECT:
28825 case COLUMN:
28826 case COMMENT:
28827 case COMMIT:
28828 case COMPRESS:
28829 case CONNECT:
28830 case CONSTANT:
28831 case CONSTRUCTOR:
28832 case CONTINUE:
28833 case CONVERT:
28834 case CREATE:
28835 case CURRENT:
28836 case CURRVAL:
28837 case CURSOR:
28838 case DATA:
28839 case DATE:
28840 case DAY:
28841 case DECLARE:
28842 case DECIMAL:
28843 case _DEFAULT:
28844 case DELETE:
28845 case DESC:
28846 case DISABLE:
28847 case DISTINCT:
28848 case DO:
28849 case DROP:
28850 case EDITIONABLE:
28851 case ELEMENT:
28852 case ELSE:
28853 case ELSIF:
28854 case ENABLE:
28855 case ESCAPE:
28856 case EXCEPT:
28857 case EXCEPTION:
28858 case EXCEPTIONS:
28859 case EXCLUSIVE:
28860 case EXECUTE:
28861 case EXISTS:
28862 case EXIT:
28863 case EXTERNAL:
28864 case EXTENDS:
28865 case EXTRACT:
28866 case FALSE:
28867 case FETCH:
28868 case FINAL:
28869 case FLOAT:
28870 case FOR:
28871 case FORALL:
28872 case FORCE:
28873 case FROM:
28874 case FUNCTION:
28875 case GLOBAL:
28876 case GOTO:
28877 case GROUP:
28878 case HASH:
28879 case HAVING:
28880 case HEAP:
28881 case HOUR:
28882 case IF:
28883 case IMMEDIATE:
28884 case IN:
28885 case INDEX:
28886 case INDICES:
28887 case INDEXTYPE:
28888 case INDICATOR:
28889 case INSERT:
28890 case INSTANTIABLE:
28891 case INTEGER:
28892 case INTERFACE:
28893 case INTERSECT:
28894 case INTERVAL:
28895 case INTO:
28896 case INVALIDATE:
28897 case IS:
28898 case ISOLATION:
28899 case JAVA:
28900 case LEVEL:
28901 case LIKE:
28902 case LIMIT:
28903 case LIMITED:
28904 case LOCK:
28905 case LONG:
28906 case LOOP:
28907 case MAP:
28908 case MAX:
28909 case MEMBER:
28910 case MERGE:
28911 case MIN:
28912 case MINUS:
28913 case MINUTE:
28914 case MLSLABEL:
28915 case MODIFY:
28916 case MOD:
28917 case MODE:
28918 case MONTH:
28919 case NATURAL:
28920 case NATURALN:
28921 case NEW:
28922 case NEXTVAL:
28923 case NO:
28924 case NOCOPY:
28925 case NONEDITIONABLE:
28926 case NOT:
28927 case NOWAIT:
28928 case NULL:
28929 case NULLIF:
28930 case NUMBER:
28931 case BFILE_BASE:
28932 case BLOB_BASE:
28933 case CLOB_BASE:
28934 case DATE_BASE:
28935 case NUMBER_BASE:
28936 case OBJECT:
28937 case OCIROWID:
28938 case OF:
28939 case OID:
28940 case ON:
28941 case OPAQUE:
28942 case OPEN:
28943 case OPERATOR:
28944 case OPTION:
28945 case OR:
28946 case ORDER:
28947 case ORGANIZATION:
28948 case OTHERS:
28949 case OUT:
28950 case OVERRIDING:
28951 case PACKAGE:
28952 case PARTITION:
28953 case PCTFREE:
28954 case PLS_INTEGER:
28955 case POSITIVE:
28956 case POSITIVEN:
28957 case PRESERVE:
28958 case PRIOR:
28959 case PROMPT:
28960 case PRIVATE:
28961 case PROCEDURE:
28962 case PUBLIC:
28963 case RAISE:
28964 case RANGE:
28965 case RAW:
28966 case REAL:
28967 case RECORD:
28968 case REF:
28969 case RELEASE:
28970 case RELIES_ON:
28971 case RENAME:
28972 case RESULT:
28973 case RETURN:
28974 case RETURNING:
28975 case REVERSE:
28976 case ROLLBACK:
28977 case ROW:
28978 case ROWS:
28979 case ROWID:
28980 case ROWNUM:
28981 case ROWTYPE:
28982 case SAVE:
28983 case SAVEPOINT:
28984 case SECOND:
28985 case SELECT:
28986 case SELF:
28987 case SEPARATE:
28988 case SET:
28989 case SHARE:
28990 case SMALLINT:
28991 case SPACE:
28992 case SQL:
28993 case SQLCODE:
28994 case SQLERRM:
28995 case START:
28996 case STATIC:
28997 case STDDEV:
28998 case SUBTYPE:
28999 case SUBSTITUTABLE:
29000 case SUCCESSFUL:
29001 case SUM:
29002 case SYNONYM:
29003 case SYSDATE:
29004 case SYS_REFCURSOR:
29005 case TABLE:
29006 case TEMPORARY:
29007 case THEN:
29008 case TIME:
29009 case TIMESTAMP:
29010 case TIMEZONE_REGION:
29011 case TIMEZONE_ABBR:
29012 case TIMEZONE_MINUTE:
29013 case TIMEZONE_HOUR:
29014 case TO:
29015 case TRANSACTION:
29016 case TRIGGER:
29017 case TRUE:
29018 case TYPE:
29019 case UI:
29020 case UNDER:
29021 case USING:
29022 case WHILE:
29023 case YES:
29024 case SHOW:
29025 case A:
29026 case UPDATE:
29027 case VARCHAR:
29028 case VARCHAR2:
29029 case DOUBLE:
29030 case DEC:
29031 case PRECISION:
29032 case INT:
29033 case NUMERIC:
29034 case SIGNTYPE:
29035 case NCHAR:
29036 case NVARCHAR2:
29037 case STRING:
29038 case UROWID:
29039 case VARRAY:
29040 case VARYING:
29041 case BFILE:
29042 case BLOB:
29043 case CLOB:
29044 case NCLOB:
29045 case YEAR:
29046 case LOCAL:
29047 case WITH:
29048 case ZONE:
29049 case CHARACTER:
29050 case AFTER:
29051 case BEFORE:
29052 case OLD:
29053 case PARENT:
29054 case ANALYZE:
29055 case ASSOCIATE:
29056 case AUDIT:
29057 case COMPOUND:
29058 case DATABASE:
29059 case CALL:
29060 case DDL:
29061 case DISASSOCIATE:
29062 case EACH:
29063 case FOLLOWS:
29064 case LOGOFF:
29065 case LOGON:
29066 case NESTED:
29067 case NOAUDIT:
29068 case SCHEMA:
29069 case SERVERERROR:
29070 case SHUTDOWN:
29071 case STARTUP:
29072 case STATEMENT:
29073 case STATISTICS:
29074 case SUSPEND:
29075 case TRUNCATE:
29076 case WRAPPED:
29077 case LIBRARY:
29078 case NAME:
29079 case STRUCT:
29080 case CONTEXT:
29081 case PARAMETERS:
29082 case LENGTH:
29083 case TDO:
29084 case MAXLEN:
29085 case CHARSETID:
29086 case CHARSETFORM:
29087 case ACCEPT:
29088 case ACCESSIBLE:
29089 case COPY:
29090 case DEFINE:
29091 case DISCONNECT:
29092 case HOST:
29093 case PRINT:
29094 case QUIT:
29095 case REMARK:
29096 case UNDEFINE:
29097 case VARIABLE:
29098 case WHENEVER:
29099 case ATTACH:
29100 case CAST:
29101 case TREAT:
29102 case TRIM:
29103 case LEFT:
29104 case RIGHT:
29105 case BOTH:
29106 case EMPTY:
29107 case MULTISET:
29108 case SUBMULTISET:
29109 case LEADING:
29110 case TRAILING:
29111 case CHAR_CS:
29112 case NCHAR_CS:
29113 case DBTIMEZONE:
29114 case SESSIONTIMEZONE:
29115 case AUTHENTICATED:
29116 case LINK:
29117 case SHARED:
29118 case DIRECTORY:
29119 case USER:
29120 case IDENTIFIER:
29121 case QUOTED_LITERAL:
29122 case SQLDATA_CLASS:
29123 case CUSTOMDATUM_CLASS:
29124 case ORADATA_CLASS:
29125 case JAVA_INTERFACE_CLASS:
29126 ID();
29127 break;
29128 default:
29129 jj_la1[442] = jj_gen;
29130 ;
29131 }
29132 jj_consume_token(4);
29133 jjtree.closeNodeScope(jjtn000, true);
29134 jjtc000 = false;
29135 {if (true) return jjtn000 ;}
29136 } catch (Throwable jjte000) {
29137 if (jjtc000) {
29138 jjtree.clearNodeScope(jjtn000);
29139 jjtc000 = false;
29140 } else {
29141 jjtree.popNode();
29142 }
29143 if (jjte000 instanceof RuntimeException) {
29144 {if (true) throw (RuntimeException)jjte000;}
29145 }
29146 if (jjte000 instanceof ParseException) {
29147 {if (true) throw (ParseException)jjte000;}
29148 }
29149 {if (true) throw (Error)jjte000;}
29150 } finally {
29151 if (jjtc000) {
29152 jjtree.closeNodeScope(jjtn000, true);
29153 }
29154 }
29155 throw new Error("Missing return statement in function");
29156 }
29157
29158
29159
29160
29161
29162
29163
29164
29165 final public ASTNonDMLTrigger NonDMLTrigger() throws ParseException {
29166
29167 ASTNonDMLTrigger jjtn000 = new ASTNonDMLTrigger(this, JJTNONDMLTRIGGER);
29168 boolean jjtc000 = true;
29169 jjtree.openNodeScope(jjtn000);
29170 try {
29171 switch (jj_nt.kind) {
29172 case BEFORE:
29173 jj_consume_token(BEFORE);
29174 break;
29175 case AFTER:
29176 jj_consume_token(AFTER);
29177 break;
29178 default:
29179 jj_la1[443] = jj_gen;
29180 jj_consume_token(-1);
29181 throw new ParseException();
29182 }
29183 switch (jj_nt.kind) {
29184 case ALTER:
29185 case COMMENT:
29186 case CREATE:
29187 case DROP:
29188 case GRANT:
29189 case RENAME:
29190 case REVOKE:
29191 case ANALYZE:
29192 case ASSOCIATE:
29193 case AUDIT:
29194 case DDL:
29195 case DISASSOCIATE:
29196 case NOAUDIT:
29197 case TRUNCATE:
29198 DDLEvent();
29199 break;
29200 case LOGOFF:
29201 case LOGON:
29202 case SERVERERROR:
29203 case SHUTDOWN:
29204 case STARTUP:
29205 case SUSPEND:
29206 DatabaseEvent();
29207 break;
29208 default:
29209 jj_la1[444] = jj_gen;
29210 jj_consume_token(-1);
29211 throw new ParseException();
29212 }
29213 label_102:
29214 while (true) {
29215 switch (jj_nt.kind) {
29216 case OR:
29217 ;
29218 break;
29219 default:
29220 jj_la1[445] = jj_gen;
29221 break label_102;
29222 }
29223 jj_consume_token(OR);
29224 switch (jj_nt.kind) {
29225 case ALTER:
29226 case COMMENT:
29227 case CREATE:
29228 case DROP:
29229 case GRANT:
29230 case RENAME:
29231 case REVOKE:
29232 case ANALYZE:
29233 case ASSOCIATE:
29234 case AUDIT:
29235 case DDL:
29236 case DISASSOCIATE:
29237 case NOAUDIT:
29238 case TRUNCATE:
29239 DDLEvent();
29240 break;
29241 case LOGOFF:
29242 case LOGON:
29243 case SERVERERROR:
29244 case SHUTDOWN:
29245 case STARTUP:
29246 case SUSPEND:
29247 DatabaseEvent();
29248 break;
29249 default:
29250 jj_la1[446] = jj_gen;
29251 jj_consume_token(-1);
29252 throw new ParseException();
29253 }
29254 }
29255 jj_consume_token(ON);
29256 switch (jj_nt.kind) {
29257 case DATABASE:
29258 jj_consume_token(DATABASE);
29259 break;
29260 case REPLACE:
29261 case DEFINER:
29262 case CURRENT_USER:
29263 case SERIALLY_REUSABLE:
29264 case RESTRICT_REFERENCES:
29265 case EXCEPTION_INIT:
29266 case AUTONOMOUS_TRANSACTION:
29267 case LANGUAGE:
29268 case INLINE:
29269 case ADD:
29270 case AGGREGATE:
29271 case ALL:
29272 case ALTER:
29273 case AND:
29274 case ANY:
29275 case ARRAY:
29276 case AS:
29277 case ASC:
29278 case AT:
29279 case ATTRIBUTE:
29280 case AUTHID:
29281 case AVG:
29282 case BETWEEN:
29283 case BINARY_INTEGER:
29284 case BODY:
29285 case BOOLEAN:
29286 case BULK:
29287 case BY:
29288 case BYTE:
29289 case CASCADE:
29290 case CASE:
29291 case CHAR:
29292 case CHAR_BASE:
29293 case CHECK:
29294 case CLOSE:
29295 case CLUSTER:
29296 case COALESCE:
29297 case COLLECT:
29298 case COLUMN:
29299 case COMMENT:
29300 case COMMIT:
29301 case COMPRESS:
29302 case CONNECT:
29303 case CONSTANT:
29304 case CONSTRUCTOR:
29305 case CONTINUE:
29306 case CONVERT:
29307 case CREATE:
29308 case CURRENT:
29309 case CURRVAL:
29310 case CURSOR:
29311 case DATA:
29312 case DATE:
29313 case DAY:
29314 case DECLARE:
29315 case DECIMAL:
29316 case _DEFAULT:
29317 case DELETE:
29318 case DESC:
29319 case DISABLE:
29320 case DISTINCT:
29321 case DO:
29322 case DROP:
29323 case EDITIONABLE:
29324 case ELEMENT:
29325 case ELSE:
29326 case ELSIF:
29327 case ENABLE:
29328 case ESCAPE:
29329 case EXCEPT:
29330 case EXCEPTION:
29331 case EXCEPTIONS:
29332 case EXCLUSIVE:
29333 case EXECUTE:
29334 case EXISTS:
29335 case EXIT:
29336 case EXTERNAL:
29337 case EXTENDS:
29338 case EXTRACT:
29339 case FALSE:
29340 case FETCH:
29341 case FINAL:
29342 case FLOAT:
29343 case FOR:
29344 case FORALL:
29345 case FORCE:
29346 case FROM:
29347 case FUNCTION:
29348 case GLOBAL:
29349 case GOTO:
29350 case GROUP:
29351 case HASH:
29352 case HAVING:
29353 case HEAP:
29354 case HOUR:
29355 case IF:
29356 case IMMEDIATE:
29357 case IN:
29358 case INDEX:
29359 case INDICES:
29360 case INDEXTYPE:
29361 case INDICATOR:
29362 case INSERT:
29363 case INSTANTIABLE:
29364 case INTEGER:
29365 case INTERFACE:
29366 case INTERSECT:
29367 case INTERVAL:
29368 case INTO:
29369 case INVALIDATE:
29370 case IS:
29371 case ISOLATION:
29372 case JAVA:
29373 case LEVEL:
29374 case LIKE:
29375 case LIMIT:
29376 case LIMITED:
29377 case LOCK:
29378 case LONG:
29379 case LOOP:
29380 case MAP:
29381 case MAX:
29382 case MEMBER:
29383 case MERGE:
29384 case MIN:
29385 case MINUS:
29386 case MINUTE:
29387 case MLSLABEL:
29388 case MODIFY:
29389 case MOD:
29390 case MODE:
29391 case MONTH:
29392 case NATURAL:
29393 case NATURALN:
29394 case NEW:
29395 case NEXTVAL:
29396 case NO:
29397 case NOCOPY:
29398 case NONEDITIONABLE:
29399 case NOT:
29400 case NOWAIT:
29401 case NULL:
29402 case NULLIF:
29403 case NUMBER:
29404 case BFILE_BASE:
29405 case BLOB_BASE:
29406 case CLOB_BASE:
29407 case DATE_BASE:
29408 case NUMBER_BASE:
29409 case OBJECT:
29410 case OCIROWID:
29411 case OF:
29412 case OID:
29413 case ON:
29414 case OPAQUE:
29415 case OPEN:
29416 case OPERATOR:
29417 case OPTION:
29418 case OR:
29419 case ORDER:
29420 case ORGANIZATION:
29421 case OTHERS:
29422 case OUT:
29423 case OVERRIDING:
29424 case PACKAGE:
29425 case PARTITION:
29426 case PCTFREE:
29427 case PLS_INTEGER:
29428 case POSITIVE:
29429 case POSITIVEN:
29430 case PRESERVE:
29431 case PRIOR:
29432 case PROMPT:
29433 case PRIVATE:
29434 case PROCEDURE:
29435 case PUBLIC:
29436 case RAISE:
29437 case RANGE:
29438 case RAW:
29439 case REAL:
29440 case RECORD:
29441 case REF:
29442 case RELEASE:
29443 case RELIES_ON:
29444 case RENAME:
29445 case RESULT:
29446 case RETURN:
29447 case RETURNING:
29448 case REVERSE:
29449 case ROLLBACK:
29450 case ROW:
29451 case ROWS:
29452 case ROWID:
29453 case ROWNUM:
29454 case ROWTYPE:
29455 case SAVE:
29456 case SAVEPOINT:
29457 case SECOND:
29458 case SELECT:
29459 case SELF:
29460 case SEPARATE:
29461 case SET:
29462 case SHARE:
29463 case SMALLINT:
29464 case SPACE:
29465 case SQL:
29466 case SQLCODE:
29467 case SQLERRM:
29468 case START:
29469 case STATIC:
29470 case STDDEV:
29471 case SUBTYPE:
29472 case SUBSTITUTABLE:
29473 case SUCCESSFUL:
29474 case SUM:
29475 case SYNONYM:
29476 case SYSDATE:
29477 case SYS_REFCURSOR:
29478 case TABLE:
29479 case TEMPORARY:
29480 case THEN:
29481 case TIME:
29482 case TIMESTAMP:
29483 case TIMEZONE_REGION:
29484 case TIMEZONE_ABBR:
29485 case TIMEZONE_MINUTE:
29486 case TIMEZONE_HOUR:
29487 case TO:
29488 case TRANSACTION:
29489 case TRIGGER:
29490 case TRUE:
29491 case TYPE:
29492 case UI:
29493 case UNDER:
29494 case USING:
29495 case WHILE:
29496 case YES:
29497 case SHOW:
29498 case A:
29499 case UPDATE:
29500 case VARCHAR:
29501 case VARCHAR2:
29502 case DOUBLE:
29503 case DEC:
29504 case PRECISION:
29505 case INT:
29506 case NUMERIC:
29507 case SIGNTYPE:
29508 case NCHAR:
29509 case NVARCHAR2:
29510 case STRING:
29511 case UROWID:
29512 case VARRAY:
29513 case VARYING:
29514 case BFILE:
29515 case BLOB:
29516 case CLOB:
29517 case NCLOB:
29518 case YEAR:
29519 case LOCAL:
29520 case WITH:
29521 case ZONE:
29522 case CHARACTER:
29523 case AFTER:
29524 case BEFORE:
29525 case OLD:
29526 case PARENT:
29527 case ANALYZE:
29528 case ASSOCIATE:
29529 case AUDIT:
29530 case COMPOUND:
29531 case CALL:
29532 case DDL:
29533 case DISASSOCIATE:
29534 case EACH:
29535 case FOLLOWS:
29536 case LOGOFF:
29537 case LOGON:
29538 case NESTED:
29539 case NOAUDIT:
29540 case SCHEMA:
29541 case SERVERERROR:
29542 case SHUTDOWN:
29543 case STARTUP:
29544 case STATEMENT:
29545 case STATISTICS:
29546 case SUSPEND:
29547 case TRUNCATE:
29548 case WRAPPED:
29549 case LIBRARY:
29550 case NAME:
29551 case STRUCT:
29552 case CONTEXT:
29553 case PARAMETERS:
29554 case LENGTH:
29555 case TDO:
29556 case MAXLEN:
29557 case CHARSETID:
29558 case CHARSETFORM:
29559 case ACCEPT:
29560 case ACCESSIBLE:
29561 case COPY:
29562 case DEFINE:
29563 case DISCONNECT:
29564 case HOST:
29565 case PRINT:
29566 case QUIT:
29567 case REMARK:
29568 case UNDEFINE:
29569 case VARIABLE:
29570 case WHENEVER:
29571 case ATTACH:
29572 case CAST:
29573 case TREAT:
29574 case TRIM:
29575 case LEFT:
29576 case RIGHT:
29577 case BOTH:
29578 case EMPTY:
29579 case MULTISET:
29580 case SUBMULTISET:
29581 case LEADING:
29582 case TRAILING:
29583 case CHAR_CS:
29584 case NCHAR_CS:
29585 case DBTIMEZONE:
29586 case SESSIONTIMEZONE:
29587 case AUTHENTICATED:
29588 case LINK:
29589 case SHARED:
29590 case DIRECTORY:
29591 case USER:
29592 case IDENTIFIER:
29593 case QUOTED_LITERAL:
29594 case SQLDATA_CLASS:
29595 case CUSTOMDATUM_CLASS:
29596 case ORADATA_CLASS:
29597 case JAVA_INTERFACE_CLASS:
29598 if (jj_2_84(2)) {
29599 ID();
29600 jj_consume_token(3);
29601 } else {
29602 ;
29603 }
29604 jj_consume_token(SCHEMA);
29605 break;
29606 default:
29607 jj_la1[447] = jj_gen;
29608 jj_consume_token(-1);
29609 throw new ParseException();
29610 }
29611 jjtree.closeNodeScope(jjtn000, true);
29612 jjtc000 = false;
29613 {if (true) return jjtn000 ;}
29614 } catch (Throwable jjte000) {
29615 if (jjtc000) {
29616 jjtree.clearNodeScope(jjtn000);
29617 jjtc000 = false;
29618 } else {
29619 jjtree.popNode();
29620 }
29621 if (jjte000 instanceof RuntimeException) {
29622 {if (true) throw (RuntimeException)jjte000;}
29623 }
29624 if (jjte000 instanceof ParseException) {
29625 {if (true) throw (ParseException)jjte000;}
29626 }
29627 {if (true) throw (Error)jjte000;}
29628 } finally {
29629 if (jjtc000) {
29630 jjtree.closeNodeScope(jjtn000, true);
29631 }
29632 }
29633 throw new Error("Missing return statement in function");
29634 }
29635
29636 final public ASTDDLEvent DDLEvent() throws ParseException {
29637
29638 ASTDDLEvent jjtn000 = new ASTDDLEvent(this, JJTDDLEVENT);
29639 boolean jjtc000 = true;
29640 jjtree.openNodeScope(jjtn000);
29641 try {
29642 switch (jj_nt.kind) {
29643 case ALTER:
29644 jj_consume_token(ALTER);
29645 break;
29646 case ANALYZE:
29647 jj_consume_token(ANALYZE);
29648 break;
29649 case ASSOCIATE:
29650 jj_consume_token(ASSOCIATE);
29651 jj_consume_token(STATISTICS);
29652 break;
29653 case AUDIT:
29654 jj_consume_token(AUDIT);
29655 break;
29656 case COMMENT:
29657 jj_consume_token(COMMENT);
29658 break;
29659 case CREATE:
29660 jj_consume_token(CREATE);
29661 break;
29662 case DISASSOCIATE:
29663 jj_consume_token(DISASSOCIATE);
29664 jj_consume_token(STATISTICS);
29665 break;
29666 case DROP:
29667 jj_consume_token(DROP);
29668 break;
29669 case GRANT:
29670 jj_consume_token(GRANT);
29671 break;
29672 case NOAUDIT:
29673 jj_consume_token(NOAUDIT);
29674 break;
29675 case RENAME:
29676 jj_consume_token(RENAME);
29677 break;
29678 case REVOKE:
29679 jj_consume_token(REVOKE);
29680 break;
29681 case TRUNCATE:
29682 jj_consume_token(TRUNCATE);
29683 break;
29684 case DDL:
29685 jj_consume_token(DDL);
29686 break;
29687 default:
29688 jj_la1[448] = jj_gen;
29689 jj_consume_token(-1);
29690 throw new ParseException();
29691 }
29692 jjtree.closeNodeScope(jjtn000, true);
29693 jjtc000 = false;
29694 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
29695 } finally {
29696 if (jjtc000) {
29697 jjtree.closeNodeScope(jjtn000, true);
29698 }
29699 }
29700 throw new Error("Missing return statement in function");
29701 }
29702
29703 final public ASTDatabaseEvent DatabaseEvent() throws ParseException {
29704
29705 ASTDatabaseEvent jjtn000 = new ASTDatabaseEvent(this, JJTDATABASEEVENT);
29706 boolean jjtc000 = true;
29707 jjtree.openNodeScope(jjtn000);
29708 try {
29709 switch (jj_nt.kind) {
29710 case STARTUP:
29711 jj_consume_token(STARTUP);
29712 break;
29713 case SHUTDOWN:
29714 jj_consume_token(SHUTDOWN);
29715 break;
29716 case LOGON:
29717 jj_consume_token(LOGON);
29718 break;
29719 case LOGOFF:
29720 jj_consume_token(LOGOFF);
29721 break;
29722 case SERVERERROR:
29723 jj_consume_token(SERVERERROR);
29724 break;
29725 case SUSPEND:
29726 jj_consume_token(SUSPEND);
29727 break;
29728 default:
29729 jj_la1[449] = jj_gen;
29730 jj_consume_token(-1);
29731 throw new ParseException();
29732 }
29733 jjtree.closeNodeScope(jjtn000, true);
29734 jjtc000 = false;
29735 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
29736 } finally {
29737 if (jjtc000) {
29738 jjtree.closeNodeScope(jjtn000, true);
29739 }
29740 }
29741 throw new Error("Missing return statement in function");
29742 }
29743
29744 final public ASTNonDMLEvent NonDMLEvent() throws ParseException {
29745
29746 ASTNonDMLEvent jjtn000 = new ASTNonDMLEvent(this, JJTNONDMLEVENT);
29747 boolean jjtc000 = true;
29748 jjtree.openNodeScope(jjtn000);
29749 try {
29750 switch (jj_nt.kind) {
29751 case ALTER:
29752 case COMMENT:
29753 case CREATE:
29754 case DROP:
29755 case GRANT:
29756 case RENAME:
29757 case REVOKE:
29758 case ANALYZE:
29759 case ASSOCIATE:
29760 case AUDIT:
29761 case DDL:
29762 case DISASSOCIATE:
29763 case NOAUDIT:
29764 case TRUNCATE:
29765 DDLEvent();
29766 break;
29767 case LOGOFF:
29768 case LOGON:
29769 case SERVERERROR:
29770 case SHUTDOWN:
29771 case STARTUP:
29772 case SUSPEND:
29773 DatabaseEvent();
29774 break;
29775 default:
29776 jj_la1[450] = jj_gen;
29777 jj_consume_token(-1);
29778 throw new ParseException();
29779 }
29780 jjtree.closeNodeScope(jjtn000, true);
29781 jjtc000 = false;
29782 {if (true) return jjtn000;}
29783 } catch (Throwable jjte000) {
29784 if (jjtc000) {
29785 jjtree.clearNodeScope(jjtn000);
29786 jjtc000 = false;
29787 } else {
29788 jjtree.popNode();
29789 }
29790 if (jjte000 instanceof RuntimeException) {
29791 {if (true) throw (RuntimeException)jjte000;}
29792 }
29793 if (jjte000 instanceof ParseException) {
29794 {if (true) throw (ParseException)jjte000;}
29795 }
29796 {if (true) throw (Error)jjte000;}
29797 } finally {
29798 if (jjtc000) {
29799 jjtree.closeNodeScope(jjtn000, true);
29800 }
29801 }
29802 throw new Error("Missing return statement in function");
29803 }
29804
29805
29806
29807
29808
29809
29810
29811
29812 final public void AlterTrigger() throws ParseException {
29813
29814 ASTAlterTrigger jjtn000 = new ASTAlterTrigger(this, JJTALTERTRIGGER);
29815 boolean jjtc000 = true;
29816 jjtree.openNodeScope(jjtn000);
29817 try {
29818 jj_consume_token(ALTER);
29819 jj_consume_token(TRIGGER);
29820 Skip2NextTerminator(null,";");
29821 jj_consume_token(4);
29822 jjtree.closeNodeScope(jjtn000, true);
29823 jjtc000 = false;
29824 {if (true) return;}
29825 } catch (Throwable jjte000) {
29826 if (jjtc000) {
29827 jjtree.clearNodeScope(jjtn000);
29828 jjtc000 = false;
29829 } else {
29830 jjtree.popNode();
29831 }
29832 if (jjte000 instanceof RuntimeException) {
29833 {if (true) throw (RuntimeException)jjte000;}
29834 }
29835 if (jjte000 instanceof ParseException) {
29836 {if (true) throw (ParseException)jjte000;}
29837 }
29838 {if (true) throw (Error)jjte000;}
29839 } finally {
29840 if (jjtc000) {
29841 jjtree.closeNodeScope(jjtn000, true);
29842 }
29843 }
29844 }
29845
29846
29847 final public ASTKEYWORD_RESERVED KEYWORD_RESERVED() throws ParseException {
29848
29849 ASTKEYWORD_RESERVED jjtn000 = new ASTKEYWORD_RESERVED(this, JJTKEYWORD_RESERVED);
29850 boolean jjtc000 = true;
29851 jjtree.openNodeScope(jjtn000);
29852 try {
29853 switch (jj_nt.kind) {
29854 case ALL:
29855 jj_consume_token(ALL);
29856 break;
29857 case ALTER:
29858 jj_consume_token(ALTER);
29859 break;
29860 case AND:
29861 jj_consume_token(AND);
29862 break;
29863 case ANY:
29864 jj_consume_token(ANY);
29865 break;
29866 case AS:
29867 jj_consume_token(AS);
29868 break;
29869 case ASC:
29870 jj_consume_token(ASC);
29871 break;
29872 case BETWEEN:
29873 jj_consume_token(BETWEEN);
29874 break;
29875 case BY:
29876 jj_consume_token(BY);
29877 break;
29878 case CHAR:
29879 jj_consume_token(CHAR);
29880 break;
29881 case CHECK:
29882 jj_consume_token(CHECK);
29883 break;
29884 case CLUSTER:
29885 jj_consume_token(CLUSTER);
29886 break;
29887 case COMPRESS:
29888 jj_consume_token(COMPRESS);
29889 break;
29890 case CONNECT:
29891 jj_consume_token(CONNECT);
29892 break;
29893 case CREATE:
29894 jj_consume_token(CREATE);
29895 break;
29896 case DATE:
29897 jj_consume_token(DATE);
29898 break;
29899 case DECIMAL:
29900 jj_consume_token(DECIMAL);
29901 break;
29902 case _DEFAULT:
29903 jj_consume_token(_DEFAULT);
29904 break;
29905 case DELETE:
29906 jj_consume_token(DELETE);
29907 break;
29908 case DESC:
29909 jj_consume_token(DESC);
29910 break;
29911 case DISTINCT:
29912 jj_consume_token(DISTINCT);
29913 break;
29914 case DROP:
29915 jj_consume_token(DROP);
29916 break;
29917 case ELSE:
29918 jj_consume_token(ELSE);
29919 break;
29920 case EXCLUSIVE:
29921 jj_consume_token(EXCLUSIVE);
29922 break;
29923 case EXISTS:
29924 jj_consume_token(EXISTS);
29925 break;
29926 case FLOAT:
29927 jj_consume_token(FLOAT);
29928 break;
29929 case FOR:
29930 jj_consume_token(FOR);
29931 break;
29932 case FROM:
29933 jj_consume_token(FROM);
29934 break;
29935 case GRANT:
29936 jj_consume_token(GRANT);
29937 break;
29938 case GROUP:
29939 jj_consume_token(GROUP);
29940 break;
29941 case HAVING:
29942 jj_consume_token(HAVING);
29943 break;
29944 case IDENTIFIED:
29945 jj_consume_token(IDENTIFIED);
29946 break;
29947 case IN:
29948 jj_consume_token(IN);
29949 break;
29950 case INDEX:
29951 jj_consume_token(INDEX);
29952 break;
29953 case INSERT:
29954 jj_consume_token(INSERT);
29955 break;
29956 case INTEGER:
29957 jj_consume_token(INTEGER);
29958 break;
29959 case INTERSECT:
29960 jj_consume_token(INTERSECT);
29961 break;
29962 case INTO:
29963 jj_consume_token(INTO);
29964 break;
29965 case IS:
29966 jj_consume_token(IS);
29967 break;
29968 case LIKE:
29969 jj_consume_token(LIKE);
29970 break;
29971 case LOCK:
29972 jj_consume_token(LOCK);
29973 break;
29974 case LONG:
29975 jj_consume_token(LONG);
29976 break;
29977 case MINUS:
29978 jj_consume_token(MINUS);
29979 break;
29980 case MODE:
29981 jj_consume_token(MODE);
29982 break;
29983 case NOCOMPRESS:
29984 jj_consume_token(NOCOMPRESS);
29985 break;
29986 case NOT:
29987 jj_consume_token(NOT);
29988 break;
29989 case NOWAIT:
29990 jj_consume_token(NOWAIT);
29991 break;
29992 case NULL:
29993 jj_consume_token(NULL);
29994 break;
29995 case NUMBER:
29996 jj_consume_token(NUMBER);
29997 break;
29998 case OF:
29999 jj_consume_token(OF);
30000 break;
30001 case ON:
30002 jj_consume_token(ON);
30003 break;
30004 case OPTION:
30005 jj_consume_token(OPTION);
30006 break;
30007 case OR:
30008 jj_consume_token(OR);
30009 break;
30010 case ORDER:
30011 jj_consume_token(ORDER);
30012 break;
30013 case PCTFREE:
30014 jj_consume_token(PCTFREE);
30015 break;
30016 case PRIOR:
30017 jj_consume_token(PRIOR);
30018 break;
30019 case PUBLIC:
30020 jj_consume_token(PUBLIC);
30021 break;
30022 case RAW:
30023 jj_consume_token(RAW);
30024 break;
30025 case RESOURCE:
30026 jj_consume_token(RESOURCE);
30027 break;
30028 case REVOKE:
30029 jj_consume_token(REVOKE);
30030 break;
30031 case SELECT:
30032 jj_consume_token(SELECT);
30033 break;
30034 case SET:
30035 jj_consume_token(SET);
30036 break;
30037 case SHARE:
30038 jj_consume_token(SHARE);
30039 break;
30040 case SIZE:
30041 jj_consume_token(SIZE);
30042 break;
30043 case SMALLINT:
30044 jj_consume_token(SMALLINT);
30045 break;
30046 case START:
30047 jj_consume_token(START);
30048 break;
30049 case SYNONYM:
30050 jj_consume_token(SYNONYM);
30051 break;
30052 case TABLE:
30053 jj_consume_token(TABLE);
30054 break;
30055 case THEN:
30056 jj_consume_token(THEN);
30057 break;
30058 case TO:
30059 jj_consume_token(TO);
30060 break;
30061 case TRIGGER:
30062 jj_consume_token(TRIGGER);
30063 break;
30064 case UNION:
30065 jj_consume_token(UNION);
30066 break;
30067 case UNIQUE:
30068 jj_consume_token(UNIQUE);
30069 break;
30070 case UPDATE:
30071 jj_consume_token(UPDATE);
30072 break;
30073 case VALUES:
30074 jj_consume_token(VALUES);
30075 break;
30076 case VARCHAR:
30077 jj_consume_token(VARCHAR);
30078 break;
30079 case VARCHAR2:
30080 jj_consume_token(VARCHAR2);
30081 break;
30082 case VIEW:
30083 jj_consume_token(VIEW);
30084 break;
30085 case WHERE:
30086 jj_consume_token(WHERE);
30087 break;
30088 case WITH:
30089 jj_consume_token(WITH);
30090 break;
30091 default:
30092 jj_la1[451] = jj_gen;
30093 jj_consume_token(-1);
30094 throw new ParseException();
30095 }
30096 jjtree.closeNodeScope(jjtn000, true);
30097 jjtc000 = false;
30098 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
30099 } finally {
30100 if (jjtc000) {
30101 jjtree.closeNodeScope(jjtn000, true);
30102 }
30103 }
30104 throw new Error("Missing return statement in function");
30105 }
30106
30107 final public ASTKEYWORD_UNRESERVED KEYWORD_UNRESERVED() throws ParseException {
30108
30109 ASTKEYWORD_UNRESERVED jjtn000 = new ASTKEYWORD_UNRESERVED(this, JJTKEYWORD_UNRESERVED);
30110 boolean jjtc000 = true;
30111 jjtree.openNodeScope(jjtn000);
30112 try {
30113 switch (jj_nt.kind) {
30114 case FALSE:
30115 jj_consume_token(FALSE);
30116 break;
30117 case TRUE:
30118 jj_consume_token(TRUE);
30119 break;
30120 case A:
30121 jj_consume_token(A);
30122 break;
30123 case ACCEPT:
30124 jj_consume_token(ACCEPT);
30125 break;
30126 case ADD:
30127 jj_consume_token(ADD);
30128 break;
30129 case AFTER:
30130 jj_consume_token(AFTER);
30131 break;
30132 case AGGREGATE:
30133 jj_consume_token(AGGREGATE);
30134 break;
30135 case ANALYZE:
30136 jj_consume_token(ANALYZE);
30137 break;
30138 case ASSOCIATE:
30139 jj_consume_token(ASSOCIATE);
30140 break;
30141 case AT:
30142 jj_consume_token(AT);
30143 break;
30144 case ATTACH:
30145 jj_consume_token(ATTACH);
30146 break;
30147 case ATTRIBUTE:
30148 jj_consume_token(ATTRIBUTE);
30149 break;
30150 case AUDIT:
30151 jj_consume_token(AUDIT);
30152 break;
30153 case AUTHENTICATED:
30154 jj_consume_token(AUTHENTICATED);
30155 break;
30156 case AUTHID:
30157 jj_consume_token(AUTHID);
30158 break;
30159 case BEFORE:
30160 jj_consume_token(BEFORE);
30161 break;
30162 case BFILE:
30163 jj_consume_token(BFILE);
30164 break;
30165 case BLOB:
30166 jj_consume_token(BLOB);
30167 break;
30168 case BOTH:
30169 jj_consume_token(BOTH);
30170 break;
30171 case BULK:
30172 jj_consume_token(BULK);
30173 break;
30174 case BYTE:
30175 jj_consume_token(BYTE);
30176 break;
30177 case CALL:
30178 jj_consume_token(CALL);
30179 break;
30180 case CASCADE:
30181 jj_consume_token(CASCADE);
30182 break;
30183 case CAST:
30184 jj_consume_token(CAST);
30185 break;
30186 case CHAR_CS:
30187 jj_consume_token(CHAR_CS);
30188 break;
30189 case CHARACTER:
30190 jj_consume_token(CHARACTER);
30191 break;
30192 case CHARSETFORM:
30193 jj_consume_token(CHARSETFORM);
30194 break;
30195 case CHARSETID:
30196 jj_consume_token(CHARSETID);
30197 break;
30198 case CLOB:
30199 jj_consume_token(CLOB);
30200 break;
30201 case CLOSE:
30202 jj_consume_token(CLOSE);
30203 break;
30204 case COALESCE:
30205 jj_consume_token(COALESCE);
30206 break;
30207 case COLLECT:
30208 jj_consume_token(COLLECT);
30209 break;
30210 case COLUMN:
30211 jj_consume_token(COLUMN);
30212 break;
30213 case COMMENT:
30214 jj_consume_token(COMMENT);
30215 break;
30216 case COMMIT:
30217 jj_consume_token(COMMIT);
30218 break;
30219 case COMPOUND:
30220 jj_consume_token(COMPOUND);
30221 break;
30222 case CONSTRUCTOR:
30223 jj_consume_token(CONSTRUCTOR);
30224 break;
30225 case CONTEXT:
30226 jj_consume_token(CONTEXT);
30227 break;
30228 case CONTINUE:
30229 jj_consume_token(CONTINUE);
30230 break;
30231 case CONVERT:
30232 jj_consume_token(CONVERT);
30233 break;
30234 case COPY:
30235 jj_consume_token(COPY);
30236 break;
30237 case CURRENT:
30238 jj_consume_token(CURRENT);
30239 break;
30240 case CURRENT_USER:
30241 jj_consume_token(CURRENT_USER);
30242 break;
30243 case CURSOR:
30244 jj_consume_token(CURSOR);
30245 break;
30246 case DATA:
30247 jj_consume_token(DATA);
30248 break;
30249 case DATABASE:
30250 jj_consume_token(DATABASE);
30251 break;
30252 case DAY:
30253 jj_consume_token(DAY);
30254 break;
30255 case DBTIMEZONE:
30256 jj_consume_token(DBTIMEZONE);
30257 break;
30258 case DDL:
30259 jj_consume_token(DDL);
30260 break;
30261 case DEC:
30262 jj_consume_token(DEC);
30263 break;
30264 case DEFINE:
30265 jj_consume_token(DEFINE);
30266 break;
30267 case DEFINER:
30268 jj_consume_token(DEFINER);
30269 break;
30270 case DIRECTORY:
30271 jj_consume_token(DIRECTORY);
30272 break;
30273 case DISABLE:
30274 jj_consume_token(DISABLE);
30275 break;
30276 case DISASSOCIATE:
30277 jj_consume_token(DISASSOCIATE);
30278 break;
30279 case DISCONNECT:
30280 jj_consume_token(DISCONNECT);
30281 break;
30282 case DOUBLE:
30283 jj_consume_token(DOUBLE);
30284 break;
30285 case EACH:
30286 jj_consume_token(EACH);
30287 break;
30288 case ELEMENT:
30289 jj_consume_token(ELEMENT);
30290 break;
30291 case EMPTY:
30292 jj_consume_token(EMPTY);
30293 break;
30294 case ENABLE:
30295 jj_consume_token(ENABLE);
30296 break;
30297 case ESCAPE:
30298 jj_consume_token(ESCAPE);
30299 break;
30300 case EXCEPT:
30301 jj_consume_token(EXCEPT);
30302 break;
30303 case EXCEPTIONS:
30304 jj_consume_token(EXCEPTIONS);
30305 break;
30306 case EXIT:
30307 jj_consume_token(EXIT);
30308 break;
30309 case EXTENDS:
30310 jj_consume_token(EXTENDS);
30311 break;
30312 case EXTERNAL:
30313 jj_consume_token(EXTERNAL);
30314 break;
30315 case EXTRACT:
30316 jj_consume_token(EXTRACT);
30317 break;
30318 case FINAL:
30319 jj_consume_token(FINAL);
30320 break;
30321 case FOLLOWS:
30322 jj_consume_token(FOLLOWS);
30323 break;
30324 case FORCE:
30325 jj_consume_token(FORCE);
30326 break;
30327 case FUNCTION:
30328 jj_consume_token(FUNCTION);
30329 break;
30330 case GLOBAL:
30331 jj_consume_token(GLOBAL);
30332 break;
30333 case HASH:
30334 jj_consume_token(HASH);
30335 break;
30336 case HEAP:
30337 jj_consume_token(HEAP);
30338 break;
30339 case HOST:
30340 jj_consume_token(HOST);
30341 break;
30342 case HOUR:
30343 jj_consume_token(HOUR);
30344 break;
30345 case IMMEDIATE:
30346 jj_consume_token(IMMEDIATE);
30347 break;
30348 case INDEXTYPE:
30349 jj_consume_token(INDEXTYPE);
30350 break;
30351 case INDICATOR:
30352 jj_consume_token(INDICATOR);
30353 break;
30354 case INDICES:
30355 jj_consume_token(INDICES);
30356 break;
30357 case INSTANTIABLE:
30358 jj_consume_token(INSTANTIABLE);
30359 break;
30360 case INTERVAL:
30361 jj_consume_token(INTERVAL);
30362 break;
30363 case INVALIDATE:
30364 jj_consume_token(INVALIDATE);
30365 break;
30366 case ISOLATION:
30367 jj_consume_token(ISOLATION);
30368 break;
30369 case JAVA:
30370 jj_consume_token(JAVA);
30371 break;
30372 case LANGUAGE:
30373 jj_consume_token(LANGUAGE);
30374 break;
30375 case LEADING:
30376 jj_consume_token(LEADING);
30377 break;
30378 case LEFT:
30379 jj_consume_token(LEFT);
30380 break;
30381 case LENGTH:
30382 jj_consume_token(LENGTH);
30383 break;
30384 case LEVEL:
30385 jj_consume_token(LEVEL);
30386 break;
30387 case LIBRARY:
30388 jj_consume_token(LIBRARY);
30389 break;
30390 case LIMIT:
30391 jj_consume_token(LIMIT);
30392 break;
30393 case LINK:
30394 jj_consume_token(LINK);
30395 break;
30396 case LOCAL:
30397 jj_consume_token(LOCAL);
30398 break;
30399 case LOGOFF:
30400 jj_consume_token(LOGOFF);
30401 break;
30402 case LOGON:
30403 jj_consume_token(LOGON);
30404 break;
30405 case MAP:
30406 jj_consume_token(MAP);
30407 break;
30408 case MAX:
30409 jj_consume_token(MAX);
30410 break;
30411 case MAXLEN:
30412 jj_consume_token(MAXLEN);
30413 break;
30414 case MEMBER:
30415 jj_consume_token(MEMBER);
30416 break;
30417 case MERGE:
30418 jj_consume_token(MERGE);
30419 break;
30420 case MIN:
30421 jj_consume_token(MIN);
30422 break;
30423 case MINUTE:
30424 jj_consume_token(MINUTE);
30425 break;
30426 case MLSLABEL:
30427 jj_consume_token(MLSLABEL);
30428 break;
30429 case MODIFY:
30430 jj_consume_token(MODIFY);
30431 break;
30432 case MONTH:
30433 jj_consume_token(MONTH);
30434 break;
30435 case MULTISET:
30436 jj_consume_token(MULTISET);
30437 break;
30438 case NAME:
30439 jj_consume_token(NAME);
30440 break;
30441 case NATURAL:
30442 jj_consume_token(NATURAL);
30443 break;
30444 case NCHAR:
30445 jj_consume_token(NCHAR);
30446 break;
30447 case NCHAR_CS:
30448 jj_consume_token(NCHAR_CS);
30449 break;
30450 case NCLOB:
30451 jj_consume_token(NCLOB);
30452 break;
30453 case NESTED:
30454 jj_consume_token(NESTED);
30455 break;
30456 case NEW:
30457 jj_consume_token(NEW);
30458 break;
30459 case NO:
30460 jj_consume_token(NO);
30461 break;
30462 case NOAUDIT:
30463 jj_consume_token(NOAUDIT);
30464 break;
30465 case NUMERIC:
30466 jj_consume_token(NUMERIC);
30467 break;
30468 case NVARCHAR2:
30469 jj_consume_token(NVARCHAR2);
30470 break;
30471 case OBJECT:
30472 jj_consume_token(OBJECT);
30473 break;
30474 case OID:
30475 jj_consume_token(OID);
30476 break;
30477 case OLD:
30478 jj_consume_token(OLD);
30479 break;
30480 case OPAQUE:
30481 jj_consume_token(OPAQUE);
30482 break;
30483 case OPEN:
30484 jj_consume_token(OPEN);
30485 break;
30486 case ORGANIZATION:
30487 jj_consume_token(ORGANIZATION);
30488 break;
30489 case OTHERS:
30490 jj_consume_token(OTHERS);
30491 break;
30492 case OVERRIDING:
30493 jj_consume_token(OVERRIDING);
30494 break;
30495 case PACKAGE:
30496 jj_consume_token(PACKAGE);
30497 break;
30498 case PARAMETERS:
30499 jj_consume_token(PARAMETERS);
30500 break;
30501 case PARENT:
30502 jj_consume_token(PARENT);
30503 break;
30504 case PARTITION:
30505 jj_consume_token(PARTITION);
30506 break;
30507 case PRECISION:
30508 jj_consume_token(PRECISION);
30509 break;
30510 case PRESERVE:
30511 jj_consume_token(PRESERVE);
30512 break;
30513 case PRINT:
30514 jj_consume_token(PRINT);
30515 break;
30516 case PROCEDURE:
30517 jj_consume_token(PROCEDURE);
30518 break;
30519 case QUIT:
30520 jj_consume_token(QUIT);
30521 break;
30522 case RANGE:
30523 jj_consume_token(RANGE);
30524 break;
30525 case REAL:
30526 jj_consume_token(REAL);
30527 break;
30528 case RECORD:
30529 jj_consume_token(RECORD);
30530 break;
30531 case REF:
30532 jj_consume_token(REF);
30533 break;
30534 case RELIES_ON:
30535 jj_consume_token(RELIES_ON);
30536 break;
30537 case REMARK:
30538 jj_consume_token(REMARK);
30539 break;
30540 case RESULT:
30541 jj_consume_token(RESULT);
30542 break;
30543 case RETURN:
30544 jj_consume_token(RETURN);
30545 break;
30546 case RETURNING:
30547 jj_consume_token(RETURNING);
30548 break;
30549 case REVERSE:
30550 jj_consume_token(REVERSE);
30551 break;
30552 case RIGHT:
30553 jj_consume_token(RIGHT);
30554 break;
30555 case ROLLBACK:
30556 jj_consume_token(ROLLBACK);
30557 break;
30558 case ROW:
30559 jj_consume_token(ROW);
30560 break;
30561 case ROWID:
30562 jj_consume_token(ROWID);
30563 break;
30564 case ROWNUM:
30565 jj_consume_token(ROWNUM);
30566 break;
30567 case ROWS:
30568 jj_consume_token(ROWS);
30569 break;
30570 case SAVE:
30571 jj_consume_token(SAVE);
30572 break;
30573 case SAVEPOINT:
30574 jj_consume_token(SAVEPOINT);
30575 break;
30576 case SCHEMA:
30577 jj_consume_token(SCHEMA);
30578 break;
30579 case SECOND:
30580 jj_consume_token(SECOND);
30581 break;
30582 case SELF:
30583 jj_consume_token(SELF);
30584 break;
30585 case SERVERERROR:
30586 jj_consume_token(SERVERERROR);
30587 break;
30588 case SESSIONTIMEZONE:
30589 jj_consume_token(SESSIONTIMEZONE);
30590 break;
30591 case SET:
30592 jj_consume_token(SET);
30593 break;
30594 case SHARED:
30595 jj_consume_token(SHARED);
30596 break;
30597 case SHUTDOWN:
30598 jj_consume_token(SHUTDOWN);
30599 break;
30600 case SPACE:
30601 jj_consume_token(SPACE);
30602 break;
30603 case STARTUP:
30604 jj_consume_token(STARTUP);
30605 break;
30606 case STATEMENT:
30607 jj_consume_token(STATEMENT);
30608 break;
30609 case STATIC:
30610 jj_consume_token(STATIC);
30611 break;
30612 case STATISTICS:
30613 jj_consume_token(STATISTICS);
30614 break;
30615 case STRUCT:
30616 jj_consume_token(STRUCT);
30617 break;
30618 case SUBMULTISET:
30619 jj_consume_token(SUBMULTISET);
30620 break;
30621 case SUBSTITUTABLE:
30622 jj_consume_token(SUBSTITUTABLE);
30623 break;
30624 case SUBTYPE:
30625 jj_consume_token(SUBTYPE);
30626 break;
30627 case SUCCESSFUL:
30628 jj_consume_token(SUCCESSFUL);
30629 break;
30630 case SUSPEND:
30631 jj_consume_token(SUSPEND);
30632 break;
30633 case TDO:
30634 jj_consume_token(TDO);
30635 break;
30636 case TEMPORARY:
30637 jj_consume_token(TEMPORARY);
30638 break;
30639 case TIME:
30640 jj_consume_token(TIME);
30641 break;
30642 case TIMESTAMP:
30643 jj_consume_token(TIMESTAMP);
30644 break;
30645 case TIMEZONE_ABBR:
30646 jj_consume_token(TIMEZONE_ABBR);
30647 break;
30648 case TIMEZONE_HOUR:
30649 jj_consume_token(TIMEZONE_HOUR);
30650 break;
30651 case TIMEZONE_MINUTE:
30652 jj_consume_token(TIMEZONE_MINUTE);
30653 break;
30654 case TIMEZONE_REGION:
30655 jj_consume_token(TIMEZONE_REGION);
30656 break;
30657 case TRAILING:
30658 jj_consume_token(TRAILING);
30659 break;
30660 case TRANSACTION:
30661 jj_consume_token(TRANSACTION);
30662 break;
30663 case TREAT:
30664 jj_consume_token(TREAT);
30665 break;
30666 case TRIM:
30667 jj_consume_token(TRIM);
30668 break;
30669 case TRUNCATE:
30670 jj_consume_token(TRUNCATE);
30671 break;
30672 case UNDEFINE:
30673 jj_consume_token(UNDEFINE);
30674 break;
30675 case UNDER:
30676 jj_consume_token(UNDER);
30677 break;
30678 case UROWID:
30679 jj_consume_token(UROWID);
30680 break;
30681 case USER:
30682 jj_consume_token(USER);
30683 break;
30684 case USING:
30685 jj_consume_token(USING);
30686 break;
30687 case VARRAY:
30688 jj_consume_token(VARRAY);
30689 break;
30690 case VARIABLE:
30691 jj_consume_token(VARIABLE);
30692 break;
30693 case VARYING:
30694 jj_consume_token(VARYING);
30695 break;
30696 case WHENEVER:
30697 jj_consume_token(WHENEVER);
30698 break;
30699 case YEAR:
30700 jj_consume_token(YEAR);
30701 break;
30702 case YES:
30703 jj_consume_token(YES);
30704 break;
30705 case ZONE:
30706 jj_consume_token(ZONE);
30707 break;
30708 case SHOW:
30709 jj_consume_token(SHOW);
30710 break;
30711 case WRAPPED:
30712 jj_consume_token(WRAPPED);
30713 break;
30714 case SYS_REFCURSOR:
30715 jj_consume_token(SYS_REFCURSOR);
30716 break;
30717 case EDITIONABLE:
30718 jj_consume_token(EDITIONABLE);
30719 break;
30720 case NONEDITIONABLE:
30721 jj_consume_token(NONEDITIONABLE);
30722 break;
30723 case ACCESSIBLE:
30724 jj_consume_token(ACCESSIBLE);
30725 break;
30726 case NULLIF:
30727 jj_consume_token(NULLIF);
30728 break;
30729 case RENAME:
30730 jj_consume_token(RENAME);
30731 break;
30732 case RELEASE:
30733 jj_consume_token(RELEASE);
30734 break;
30735 case INLINE:
30736 jj_consume_token(INLINE);
30737 break;
30738 default:
30739 jj_la1[452] = jj_gen;
30740 jj_consume_token(-1);
30741 throw new ParseException();
30742 }
30743 jjtree.closeNodeScope(jjtn000, true);
30744 jjtc000 = false;
30745 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
30746 } finally {
30747 if (jjtc000) {
30748 jjtree.closeNodeScope(jjtn000, true);
30749 }
30750 }
30751 throw new Error("Missing return statement in function");
30752 }
30753
30754
30755
30756
30757
30758 final public ASTID ID() throws ParseException {
30759
30760 ASTID jjtn000 = new ASTID(this, JJTID);
30761 boolean jjtc000 = true;
30762 jjtree.openNodeScope(jjtn000);
30763 try {
30764 switch (jj_nt.kind) {
30765 case IDENTIFIER:
30766 jj_consume_token(IDENTIFIER);
30767 break;
30768 case QUOTED_LITERAL:
30769 jj_consume_token(QUOTED_LITERAL);
30770 break;
30771 case DEFINER:
30772 case CURRENT_USER:
30773 case LANGUAGE:
30774 case INLINE:
30775 case ADD:
30776 case AGGREGATE:
30777 case AT:
30778 case ATTRIBUTE:
30779 case AUTHID:
30780 case BULK:
30781 case BYTE:
30782 case CASCADE:
30783 case CLOSE:
30784 case COALESCE:
30785 case COLLECT:
30786 case COLUMN:
30787 case COMMENT:
30788 case COMMIT:
30789 case CONSTRUCTOR:
30790 case CONTINUE:
30791 case CONVERT:
30792 case CURRENT:
30793 case CURSOR:
30794 case DATA:
30795 case DAY:
30796 case DISABLE:
30797 case EDITIONABLE:
30798 case ELEMENT:
30799 case ENABLE:
30800 case ESCAPE:
30801 case EXCEPT:
30802 case EXCEPTIONS:
30803 case EXIT:
30804 case EXTERNAL:
30805 case EXTENDS:
30806 case EXTRACT:
30807 case FALSE:
30808 case FINAL:
30809 case FORCE:
30810 case FUNCTION:
30811 case GLOBAL:
30812 case HASH:
30813 case HEAP:
30814 case HOUR:
30815 case IMMEDIATE:
30816 case INDICES:
30817 case INDEXTYPE:
30818 case INDICATOR:
30819 case INSTANTIABLE:
30820 case INTERVAL:
30821 case INVALIDATE:
30822 case ISOLATION:
30823 case JAVA:
30824 case LEVEL:
30825 case LIMIT:
30826 case MAP:
30827 case MAX:
30828 case MEMBER:
30829 case MERGE:
30830 case MIN:
30831 case MINUTE:
30832 case MLSLABEL:
30833 case MODIFY:
30834 case MONTH:
30835 case NATURAL:
30836 case NEW:
30837 case NO:
30838 case NONEDITIONABLE:
30839 case NULLIF:
30840 case OBJECT:
30841 case OID:
30842 case OPAQUE:
30843 case OPEN:
30844 case ORGANIZATION:
30845 case OTHERS:
30846 case OVERRIDING:
30847 case PACKAGE:
30848 case PARTITION:
30849 case PRESERVE:
30850 case PROCEDURE:
30851 case RANGE:
30852 case REAL:
30853 case RECORD:
30854 case REF:
30855 case RELEASE:
30856 case RELIES_ON:
30857 case RENAME:
30858 case RESULT:
30859 case RETURN:
30860 case RETURNING:
30861 case REVERSE:
30862 case ROLLBACK:
30863 case ROW:
30864 case ROWS:
30865 case ROWID:
30866 case ROWNUM:
30867 case SAVE:
30868 case SAVEPOINT:
30869 case SECOND:
30870 case SELF:
30871 case SET:
30872 case SPACE:
30873 case STATIC:
30874 case SUBTYPE:
30875 case SUBSTITUTABLE:
30876 case SUCCESSFUL:
30877 case SYS_REFCURSOR:
30878 case TEMPORARY:
30879 case TIME:
30880 case TIMESTAMP:
30881 case TIMEZONE_REGION:
30882 case TIMEZONE_ABBR:
30883 case TIMEZONE_MINUTE:
30884 case TIMEZONE_HOUR:
30885 case TRANSACTION:
30886 case TRUE:
30887 case UNDER:
30888 case USING:
30889 case YES:
30890 case SHOW:
30891 case A:
30892 case DOUBLE:
30893 case DEC:
30894 case PRECISION:
30895 case NUMERIC:
30896 case NCHAR:
30897 case NVARCHAR2:
30898 case UROWID:
30899 case VARRAY:
30900 case VARYING:
30901 case BFILE:
30902 case BLOB:
30903 case CLOB:
30904 case NCLOB:
30905 case YEAR:
30906 case LOCAL:
30907 case ZONE:
30908 case CHARACTER:
30909 case AFTER:
30910 case BEFORE:
30911 case OLD:
30912 case PARENT:
30913 case ANALYZE:
30914 case ASSOCIATE:
30915 case AUDIT:
30916 case COMPOUND:
30917 case DATABASE:
30918 case CALL:
30919 case DDL:
30920 case DISASSOCIATE:
30921 case EACH:
30922 case FOLLOWS:
30923 case LOGOFF:
30924 case LOGON:
30925 case NESTED:
30926 case NOAUDIT:
30927 case SCHEMA:
30928 case SERVERERROR:
30929 case SHUTDOWN:
30930 case STARTUP:
30931 case STATEMENT:
30932 case STATISTICS:
30933 case SUSPEND:
30934 case TRUNCATE:
30935 case WRAPPED:
30936 case LIBRARY:
30937 case NAME:
30938 case STRUCT:
30939 case CONTEXT:
30940 case PARAMETERS:
30941 case LENGTH:
30942 case TDO:
30943 case MAXLEN:
30944 case CHARSETID:
30945 case CHARSETFORM:
30946 case ACCEPT:
30947 case ACCESSIBLE:
30948 case COPY:
30949 case DEFINE:
30950 case DISCONNECT:
30951 case HOST:
30952 case PRINT:
30953 case QUIT:
30954 case REMARK:
30955 case UNDEFINE:
30956 case VARIABLE:
30957 case WHENEVER:
30958 case ATTACH:
30959 case CAST:
30960 case TREAT:
30961 case TRIM:
30962 case LEFT:
30963 case RIGHT:
30964 case BOTH:
30965 case EMPTY:
30966 case MULTISET:
30967 case SUBMULTISET:
30968 case LEADING:
30969 case TRAILING:
30970 case CHAR_CS:
30971 case NCHAR_CS:
30972 case DBTIMEZONE:
30973 case SESSIONTIMEZONE:
30974 case AUTHENTICATED:
30975 case LINK:
30976 case SHARED:
30977 case DIRECTORY:
30978 case USER:
30979 KEYWORD_UNRESERVED();
30980 break;
30981 case REPLACE:
30982 jj_consume_token(REPLACE);
30983 break;
30984 case SERIALLY_REUSABLE:
30985 jj_consume_token(SERIALLY_REUSABLE);
30986 break;
30987 case RESTRICT_REFERENCES:
30988 jj_consume_token(RESTRICT_REFERENCES);
30989 break;
30990 case EXCEPTION_INIT:
30991 jj_consume_token(EXCEPTION_INIT);
30992 break;
30993 case AUTONOMOUS_TRANSACTION:
30994 jj_consume_token(AUTONOMOUS_TRANSACTION);
30995 break;
30996 case ALL:
30997 jj_consume_token(ALL);
30998 break;
30999 case ALTER:
31000 jj_consume_token(ALTER);
31001 break;
31002 case AND:
31003 jj_consume_token(AND);
31004 break;
31005 case ANY:
31006 jj_consume_token(ANY);
31007 break;
31008 case ARRAY:
31009 jj_consume_token(ARRAY);
31010 break;
31011 case AS:
31012 jj_consume_token(AS);
31013 break;
31014 case ASC:
31015 jj_consume_token(ASC);
31016 break;
31017 case AVG:
31018 jj_consume_token(AVG);
31019 break;
31020 case BETWEEN:
31021 jj_consume_token(BETWEEN);
31022 break;
31023 case BINARY_INTEGER:
31024 jj_consume_token(BINARY_INTEGER);
31025 break;
31026 case BODY:
31027 jj_consume_token(BODY);
31028 break;
31029 case BOOLEAN:
31030 jj_consume_token(BOOLEAN);
31031 break;
31032 case BY:
31033 jj_consume_token(BY);
31034 break;
31035 case CASE:
31036 jj_consume_token(CASE);
31037 break;
31038 case CHAR:
31039 jj_consume_token(CHAR);
31040 break;
31041 case CHAR_BASE:
31042 jj_consume_token(CHAR_BASE);
31043 break;
31044 case CHECK:
31045 jj_consume_token(CHECK);
31046 break;
31047 case CLUSTER:
31048 jj_consume_token(CLUSTER);
31049 break;
31050 case COMPRESS:
31051 jj_consume_token(COMPRESS);
31052 break;
31053 case CONNECT:
31054 jj_consume_token(CONNECT);
31055 break;
31056 case CONSTANT:
31057 jj_consume_token(CONSTANT);
31058 break;
31059 case CREATE:
31060 jj_consume_token(CREATE);
31061 break;
31062 case CURRVAL:
31063 jj_consume_token(CURRVAL);
31064 break;
31065 case DATE:
31066 jj_consume_token(DATE);
31067 break;
31068 case DECLARE:
31069 jj_consume_token(DECLARE);
31070 break;
31071 case DECIMAL:
31072 jj_consume_token(DECIMAL);
31073 break;
31074 case _DEFAULT:
31075 jj_consume_token(_DEFAULT);
31076 break;
31077 case DELETE:
31078 jj_consume_token(DELETE);
31079 break;
31080 case DESC:
31081 jj_consume_token(DESC);
31082 break;
31083 case DISTINCT:
31084 jj_consume_token(DISTINCT);
31085 break;
31086 case DO:
31087 jj_consume_token(DO);
31088 break;
31089 case DROP:
31090 jj_consume_token(DROP);
31091 break;
31092 case ELSE:
31093 jj_consume_token(ELSE);
31094 break;
31095 case ELSIF:
31096 jj_consume_token(ELSIF);
31097 break;
31098 case EXCEPTION:
31099 jj_consume_token(EXCEPTION);
31100 break;
31101 case EXCLUSIVE:
31102 jj_consume_token(EXCLUSIVE);
31103 break;
31104 case EXECUTE:
31105 jj_consume_token(EXECUTE);
31106 break;
31107 case EXISTS:
31108 jj_consume_token(EXISTS);
31109 break;
31110 case FETCH:
31111 jj_consume_token(FETCH);
31112 break;
31113 case FLOAT:
31114 jj_consume_token(FLOAT);
31115 break;
31116 case FOR:
31117 jj_consume_token(FOR);
31118 break;
31119 case FORALL:
31120 jj_consume_token(FORALL);
31121 break;
31122 case FROM:
31123 jj_consume_token(FROM);
31124 break;
31125 case GOTO:
31126 jj_consume_token(GOTO);
31127 break;
31128 case GROUP:
31129 jj_consume_token(GROUP);
31130 break;
31131 case HAVING:
31132 jj_consume_token(HAVING);
31133 break;
31134 case IF:
31135 jj_consume_token(IF);
31136 break;
31137 case IN:
31138 jj_consume_token(IN);
31139 break;
31140 case INDEX:
31141 jj_consume_token(INDEX);
31142 break;
31143 case INSERT:
31144 jj_consume_token(INSERT);
31145 break;
31146 case INTEGER:
31147 jj_consume_token(INTEGER);
31148 break;
31149 case INTERFACE:
31150 jj_consume_token(INTERFACE);
31151 break;
31152 case INTERSECT:
31153 jj_consume_token(INTERSECT);
31154 break;
31155 case INTO:
31156 jj_consume_token(INTO);
31157 break;
31158 case IS:
31159 jj_consume_token(IS);
31160 break;
31161 case LIKE:
31162 jj_consume_token(LIKE);
31163 break;
31164 case LIMITED:
31165 jj_consume_token(LIMITED);
31166 break;
31167 case LOCK:
31168 jj_consume_token(LOCK);
31169 break;
31170 case LONG:
31171 jj_consume_token(LONG);
31172 break;
31173 case LOOP:
31174 jj_consume_token(LOOP);
31175 break;
31176 case MINUS:
31177 jj_consume_token(MINUS);
31178 break;
31179 case MOD:
31180 jj_consume_token(MOD);
31181 break;
31182 case MODE:
31183 jj_consume_token(MODE);
31184 break;
31185 case NATURALN:
31186 jj_consume_token(NATURALN);
31187 break;
31188 case NEXTVAL:
31189 jj_consume_token(NEXTVAL);
31190 break;
31191 case NOCOPY:
31192 jj_consume_token(NOCOPY);
31193 break;
31194 case NOT:
31195 jj_consume_token(NOT);
31196 break;
31197 case NOWAIT:
31198 jj_consume_token(NOWAIT);
31199 break;
31200 case NULL:
31201 jj_consume_token(NULL);
31202 break;
31203 case NUMBER:
31204 jj_consume_token(NUMBER);
31205 break;
31206 case NUMBER_BASE:
31207 jj_consume_token(NUMBER_BASE);
31208 break;
31209 case OCIROWID:
31210 jj_consume_token(OCIROWID);
31211 break;
31212 case OF:
31213 jj_consume_token(OF);
31214 break;
31215 case ON:
31216 jj_consume_token(ON);
31217 break;
31218 case BFILE_BASE:
31219 jj_consume_token(BFILE_BASE);
31220 break;
31221 case BLOB_BASE:
31222 jj_consume_token(BLOB_BASE);
31223 break;
31224 case CLOB_BASE:
31225 jj_consume_token(CLOB_BASE);
31226 break;
31227 case DATE_BASE:
31228 jj_consume_token(DATE_BASE);
31229 break;
31230 case OPERATOR:
31231 jj_consume_token(OPERATOR);
31232 break;
31233 case OPTION:
31234 jj_consume_token(OPTION);
31235 break;
31236 case OR:
31237 jj_consume_token(OR);
31238 break;
31239 case ORDER:
31240 jj_consume_token(ORDER);
31241 break;
31242 case OUT:
31243 jj_consume_token(OUT);
31244 break;
31245 case PCTFREE:
31246 jj_consume_token(PCTFREE);
31247 break;
31248 case PLS_INTEGER:
31249 jj_consume_token(PLS_INTEGER);
31250 break;
31251 case POSITIVE:
31252 jj_consume_token(POSITIVE);
31253 break;
31254 case POSITIVEN:
31255 jj_consume_token(POSITIVEN);
31256 break;
31257 case PRIOR:
31258 jj_consume_token(PRIOR);
31259 break;
31260 case PRIVATE:
31261 jj_consume_token(PRIVATE);
31262 break;
31263 case PROMPT:
31264 jj_consume_token(PROMPT);
31265 break;
31266 case PUBLIC:
31267 jj_consume_token(PUBLIC);
31268 break;
31269 case RAISE:
31270 jj_consume_token(RAISE);
31271 break;
31272 case RAW:
31273 jj_consume_token(RAW);
31274 break;
31275 case ROWTYPE:
31276 jj_consume_token(ROWTYPE);
31277 break;
31278 case SELECT:
31279 jj_consume_token(SELECT);
31280 break;
31281 case SEPARATE:
31282 jj_consume_token(SEPARATE);
31283 break;
31284 case SHARE:
31285 jj_consume_token(SHARE);
31286 break;
31287 case SMALLINT:
31288 jj_consume_token(SMALLINT);
31289 break;
31290 case SQL:
31291 jj_consume_token(SQL);
31292 break;
31293 case SQLCODE:
31294 jj_consume_token(SQLCODE);
31295 break;
31296 case SQLERRM:
31297 jj_consume_token(SQLERRM);
31298 break;
31299 case START:
31300 jj_consume_token(START);
31301 break;
31302 case STDDEV:
31303 jj_consume_token(STDDEV);
31304 break;
31305 case SUM:
31306 jj_consume_token(SUM);
31307 break;
31308 case SYNONYM:
31309 jj_consume_token(SYNONYM);
31310 break;
31311 case SYSDATE:
31312 jj_consume_token(SYSDATE);
31313 break;
31314 case TABLE:
31315 jj_consume_token(TABLE);
31316 break;
31317 case THEN:
31318 jj_consume_token(THEN);
31319 break;
31320 case TO:
31321 jj_consume_token(TO);
31322 break;
31323 case TRIGGER:
31324 jj_consume_token(TRIGGER);
31325 break;
31326 case TYPE:
31327 jj_consume_token(TYPE);
31328 break;
31329 case UI:
31330 jj_consume_token(UI);
31331 break;
31332 case UPDATE:
31333 jj_consume_token(UPDATE);
31334 break;
31335 case VARCHAR:
31336 jj_consume_token(VARCHAR);
31337 break;
31338 case VARCHAR2:
31339 jj_consume_token(VARCHAR2);
31340 break;
31341 case INT:
31342 jj_consume_token(INT);
31343 break;
31344 case SIGNTYPE:
31345 jj_consume_token(SIGNTYPE);
31346 break;
31347 case STRING:
31348 jj_consume_token(STRING);
31349 break;
31350 case WITH:
31351 jj_consume_token(WITH);
31352 break;
31353 case WHILE:
31354 jj_consume_token(WHILE);
31355 break;
31356 case JAVA_INTERFACE_CLASS:
31357 jj_consume_token(JAVA_INTERFACE_CLASS);
31358 break;
31359 case SQLDATA_CLASS:
31360 jj_consume_token(SQLDATA_CLASS);
31361 break;
31362 case CUSTOMDATUM_CLASS:
31363 jj_consume_token(CUSTOMDATUM_CLASS);
31364 break;
31365 case ORADATA_CLASS:
31366 jj_consume_token(ORADATA_CLASS);
31367 break;
31368 default:
31369 jj_la1[453] = jj_gen;
31370 jj_consume_token(-1);
31371 throw new ParseException();
31372 }
31373 jjtree.closeNodeScope(jjtn000, true);
31374 jjtc000 = false;
31375 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31376 } catch (Throwable jjte000) {
31377 if (jjtc000) {
31378 jjtree.clearNodeScope(jjtn000);
31379 jjtc000 = false;
31380 } else {
31381 jjtree.popNode();
31382 }
31383 if (jjte000 instanceof RuntimeException) {
31384 {if (true) throw (RuntimeException)jjte000;}
31385 }
31386 if (jjte000 instanceof ParseException) {
31387 {if (true) throw (ParseException)jjte000;}
31388 }
31389 {if (true) throw (Error)jjte000;}
31390 } finally {
31391 if (jjtc000) {
31392 jjtree.closeNodeScope(jjtn000, true);
31393 }
31394 }
31395 throw new Error("Missing return statement in function");
31396 }
31397
31398
31399
31400
31401 final public ASTUnqualifiedID UnqualifiedID() throws ParseException {
31402
31403 ASTUnqualifiedID jjtn000 = new ASTUnqualifiedID(this, JJTUNQUALIFIEDID);
31404 boolean jjtc000 = true;
31405 jjtree.openNodeScope(jjtn000);
31406 try {
31407 switch (jj_nt.kind) {
31408 case IDENTIFIER:
31409 jj_consume_token(IDENTIFIER);
31410 break;
31411 case QUOTED_LITERAL:
31412 jj_consume_token(QUOTED_LITERAL);
31413 break;
31414 case DEFINER:
31415 case CURRENT_USER:
31416 case LANGUAGE:
31417 case INLINE:
31418 case ADD:
31419 case AGGREGATE:
31420 case AT:
31421 case ATTRIBUTE:
31422 case AUTHID:
31423 case BULK:
31424 case BYTE:
31425 case CASCADE:
31426 case CLOSE:
31427 case COALESCE:
31428 case COLLECT:
31429 case COLUMN:
31430 case COMMENT:
31431 case COMMIT:
31432 case CONSTRUCTOR:
31433 case CONTINUE:
31434 case CONVERT:
31435 case CURRENT:
31436 case CURSOR:
31437 case DATA:
31438 case DAY:
31439 case DISABLE:
31440 case EDITIONABLE:
31441 case ELEMENT:
31442 case ENABLE:
31443 case ESCAPE:
31444 case EXCEPT:
31445 case EXCEPTIONS:
31446 case EXIT:
31447 case EXTERNAL:
31448 case EXTENDS:
31449 case EXTRACT:
31450 case FALSE:
31451 case FINAL:
31452 case FORCE:
31453 case FUNCTION:
31454 case GLOBAL:
31455 case HASH:
31456 case HEAP:
31457 case HOUR:
31458 case IMMEDIATE:
31459 case INDICES:
31460 case INDEXTYPE:
31461 case INDICATOR:
31462 case INSTANTIABLE:
31463 case INTERVAL:
31464 case INVALIDATE:
31465 case ISOLATION:
31466 case JAVA:
31467 case LEVEL:
31468 case LIMIT:
31469 case MAP:
31470 case MAX:
31471 case MEMBER:
31472 case MERGE:
31473 case MIN:
31474 case MINUTE:
31475 case MLSLABEL:
31476 case MODIFY:
31477 case MONTH:
31478 case NATURAL:
31479 case NEW:
31480 case NO:
31481 case NONEDITIONABLE:
31482 case NULLIF:
31483 case OBJECT:
31484 case OID:
31485 case OPAQUE:
31486 case OPEN:
31487 case ORGANIZATION:
31488 case OTHERS:
31489 case OVERRIDING:
31490 case PACKAGE:
31491 case PARTITION:
31492 case PRESERVE:
31493 case PROCEDURE:
31494 case RANGE:
31495 case REAL:
31496 case RECORD:
31497 case REF:
31498 case RELEASE:
31499 case RELIES_ON:
31500 case RENAME:
31501 case RESULT:
31502 case RETURN:
31503 case RETURNING:
31504 case REVERSE:
31505 case ROLLBACK:
31506 case ROW:
31507 case ROWS:
31508 case ROWID:
31509 case ROWNUM:
31510 case SAVE:
31511 case SAVEPOINT:
31512 case SECOND:
31513 case SELF:
31514 case SET:
31515 case SPACE:
31516 case STATIC:
31517 case SUBTYPE:
31518 case SUBSTITUTABLE:
31519 case SUCCESSFUL:
31520 case SYS_REFCURSOR:
31521 case TEMPORARY:
31522 case TIME:
31523 case TIMESTAMP:
31524 case TIMEZONE_REGION:
31525 case TIMEZONE_ABBR:
31526 case TIMEZONE_MINUTE:
31527 case TIMEZONE_HOUR:
31528 case TRANSACTION:
31529 case TRUE:
31530 case UNDER:
31531 case USING:
31532 case YES:
31533 case SHOW:
31534 case A:
31535 case DOUBLE:
31536 case DEC:
31537 case PRECISION:
31538 case NUMERIC:
31539 case NCHAR:
31540 case NVARCHAR2:
31541 case UROWID:
31542 case VARRAY:
31543 case VARYING:
31544 case BFILE:
31545 case BLOB:
31546 case CLOB:
31547 case NCLOB:
31548 case YEAR:
31549 case LOCAL:
31550 case ZONE:
31551 case CHARACTER:
31552 case AFTER:
31553 case BEFORE:
31554 case OLD:
31555 case PARENT:
31556 case ANALYZE:
31557 case ASSOCIATE:
31558 case AUDIT:
31559 case COMPOUND:
31560 case DATABASE:
31561 case CALL:
31562 case DDL:
31563 case DISASSOCIATE:
31564 case EACH:
31565 case FOLLOWS:
31566 case LOGOFF:
31567 case LOGON:
31568 case NESTED:
31569 case NOAUDIT:
31570 case SCHEMA:
31571 case SERVERERROR:
31572 case SHUTDOWN:
31573 case STARTUP:
31574 case STATEMENT:
31575 case STATISTICS:
31576 case SUSPEND:
31577 case TRUNCATE:
31578 case WRAPPED:
31579 case LIBRARY:
31580 case NAME:
31581 case STRUCT:
31582 case CONTEXT:
31583 case PARAMETERS:
31584 case LENGTH:
31585 case TDO:
31586 case MAXLEN:
31587 case CHARSETID:
31588 case CHARSETFORM:
31589 case ACCEPT:
31590 case ACCESSIBLE:
31591 case COPY:
31592 case DEFINE:
31593 case DISCONNECT:
31594 case HOST:
31595 case PRINT:
31596 case QUIT:
31597 case REMARK:
31598 case UNDEFINE:
31599 case VARIABLE:
31600 case WHENEVER:
31601 case ATTACH:
31602 case CAST:
31603 case TREAT:
31604 case TRIM:
31605 case LEFT:
31606 case RIGHT:
31607 case BOTH:
31608 case EMPTY:
31609 case MULTISET:
31610 case SUBMULTISET:
31611 case LEADING:
31612 case TRAILING:
31613 case CHAR_CS:
31614 case NCHAR_CS:
31615 case DBTIMEZONE:
31616 case SESSIONTIMEZONE:
31617 case AUTHENTICATED:
31618 case LINK:
31619 case SHARED:
31620 case DIRECTORY:
31621 case USER:
31622 KEYWORD_UNRESERVED();
31623 break;
31624 case BODY:
31625 jj_consume_token(BODY);
31626 break;
31627 case MOD:
31628 jj_consume_token(MOD);
31629 break;
31630 case OPERATOR:
31631 jj_consume_token(OPERATOR);
31632 break;
31633 case PRIVATE:
31634 jj_consume_token(PRIVATE);
31635 break;
31636 case RAW:
31637 jj_consume_token(RAW);
31638 break;
31639 case REPLACE:
31640 jj_consume_token(REPLACE);
31641 break;
31642 case STRING:
31643 jj_consume_token(STRING);
31644 break;
31645 case SQL:
31646 jj_consume_token(SQL);
31647 break;
31648 case SQLCODE:
31649 jj_consume_token(SQLCODE);
31650 break;
31651 case SQLERRM:
31652 jj_consume_token(SQLERRM);
31653 break;
31654 case SYSDATE:
31655 jj_consume_token(SYSDATE);
31656 break;
31657 case TYPE:
31658 jj_consume_token(TYPE);
31659 break;
31660 case LOOP:
31661 jj_consume_token(LOOP);
31662 break;
31663 case INT:
31664 jj_consume_token(INT);
31665 break;
31666 case ARRAY:
31667 jj_consume_token(ARRAY);
31668 break;
31669 default:
31670 jj_la1[454] = jj_gen;
31671 jj_consume_token(-1);
31672 throw new ParseException();
31673 }
31674 jjtree.closeNodeScope(jjtn000, true);
31675 jjtc000 = false;
31676 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31677 } catch (Throwable jjte000) {
31678 if (jjtc000) {
31679 jjtree.clearNodeScope(jjtn000);
31680 jjtc000 = false;
31681 } else {
31682 jjtree.popNode();
31683 }
31684 if (jjte000 instanceof RuntimeException) {
31685 {if (true) throw (RuntimeException)jjte000;}
31686 }
31687 if (jjte000 instanceof ParseException) {
31688 {if (true) throw (ParseException)jjte000;}
31689 }
31690 {if (true) throw (Error)jjte000;}
31691 } finally {
31692 if (jjtc000) {
31693 jjtree.closeNodeScope(jjtn000, true);
31694 }
31695 }
31696 throw new Error("Missing return statement in function");
31697 }
31698
31699
31700
31701
31702 final public ASTQualifiedID QualifiedID() throws ParseException {
31703
31704 ASTQualifiedID jjtn000 = new ASTQualifiedID(this, JJTQUALIFIEDID);
31705 boolean jjtc000 = true;
31706 jjtree.openNodeScope(jjtn000);
31707 try {
31708 switch (jj_nt.kind) {
31709 case IDENTIFIER:
31710 jj_consume_token(IDENTIFIER);
31711 break;
31712 case QUOTED_LITERAL:
31713 jj_consume_token(QUOTED_LITERAL);
31714 break;
31715 case DEFINER:
31716 case CURRENT_USER:
31717 case LANGUAGE:
31718 case INLINE:
31719 case ADD:
31720 case AGGREGATE:
31721 case AT:
31722 case ATTRIBUTE:
31723 case AUTHID:
31724 case BULK:
31725 case BYTE:
31726 case CASCADE:
31727 case CLOSE:
31728 case COALESCE:
31729 case COLLECT:
31730 case COLUMN:
31731 case COMMENT:
31732 case COMMIT:
31733 case CONSTRUCTOR:
31734 case CONTINUE:
31735 case CONVERT:
31736 case CURRENT:
31737 case CURSOR:
31738 case DATA:
31739 case DAY:
31740 case DISABLE:
31741 case EDITIONABLE:
31742 case ELEMENT:
31743 case ENABLE:
31744 case ESCAPE:
31745 case EXCEPT:
31746 case EXCEPTIONS:
31747 case EXIT:
31748 case EXTERNAL:
31749 case EXTENDS:
31750 case EXTRACT:
31751 case FALSE:
31752 case FINAL:
31753 case FORCE:
31754 case FUNCTION:
31755 case GLOBAL:
31756 case HASH:
31757 case HEAP:
31758 case HOUR:
31759 case IMMEDIATE:
31760 case INDICES:
31761 case INDEXTYPE:
31762 case INDICATOR:
31763 case INSTANTIABLE:
31764 case INTERVAL:
31765 case INVALIDATE:
31766 case ISOLATION:
31767 case JAVA:
31768 case LEVEL:
31769 case LIMIT:
31770 case MAP:
31771 case MAX:
31772 case MEMBER:
31773 case MERGE:
31774 case MIN:
31775 case MINUTE:
31776 case MLSLABEL:
31777 case MODIFY:
31778 case MONTH:
31779 case NATURAL:
31780 case NEW:
31781 case NO:
31782 case NONEDITIONABLE:
31783 case NULLIF:
31784 case OBJECT:
31785 case OID:
31786 case OPAQUE:
31787 case OPEN:
31788 case ORGANIZATION:
31789 case OTHERS:
31790 case OVERRIDING:
31791 case PACKAGE:
31792 case PARTITION:
31793 case PRESERVE:
31794 case PROCEDURE:
31795 case RANGE:
31796 case REAL:
31797 case RECORD:
31798 case REF:
31799 case RELEASE:
31800 case RELIES_ON:
31801 case RENAME:
31802 case RESULT:
31803 case RETURN:
31804 case RETURNING:
31805 case REVERSE:
31806 case ROLLBACK:
31807 case ROW:
31808 case ROWS:
31809 case ROWID:
31810 case ROWNUM:
31811 case SAVE:
31812 case SAVEPOINT:
31813 case SECOND:
31814 case SELF:
31815 case SET:
31816 case SPACE:
31817 case STATIC:
31818 case SUBTYPE:
31819 case SUBSTITUTABLE:
31820 case SUCCESSFUL:
31821 case SYS_REFCURSOR:
31822 case TEMPORARY:
31823 case TIME:
31824 case TIMESTAMP:
31825 case TIMEZONE_REGION:
31826 case TIMEZONE_ABBR:
31827 case TIMEZONE_MINUTE:
31828 case TIMEZONE_HOUR:
31829 case TRANSACTION:
31830 case TRUE:
31831 case UNDER:
31832 case USING:
31833 case YES:
31834 case SHOW:
31835 case A:
31836 case DOUBLE:
31837 case DEC:
31838 case PRECISION:
31839 case NUMERIC:
31840 case NCHAR:
31841 case NVARCHAR2:
31842 case UROWID:
31843 case VARRAY:
31844 case VARYING:
31845 case BFILE:
31846 case BLOB:
31847 case CLOB:
31848 case NCLOB:
31849 case YEAR:
31850 case LOCAL:
31851 case ZONE:
31852 case CHARACTER:
31853 case AFTER:
31854 case BEFORE:
31855 case OLD:
31856 case PARENT:
31857 case ANALYZE:
31858 case ASSOCIATE:
31859 case AUDIT:
31860 case COMPOUND:
31861 case DATABASE:
31862 case CALL:
31863 case DDL:
31864 case DISASSOCIATE:
31865 case EACH:
31866 case FOLLOWS:
31867 case LOGOFF:
31868 case LOGON:
31869 case NESTED:
31870 case NOAUDIT:
31871 case SCHEMA:
31872 case SERVERERROR:
31873 case SHUTDOWN:
31874 case STARTUP:
31875 case STATEMENT:
31876 case STATISTICS:
31877 case SUSPEND:
31878 case TRUNCATE:
31879 case WRAPPED:
31880 case LIBRARY:
31881 case NAME:
31882 case STRUCT:
31883 case CONTEXT:
31884 case PARAMETERS:
31885 case LENGTH:
31886 case TDO:
31887 case MAXLEN:
31888 case CHARSETID:
31889 case CHARSETFORM:
31890 case ACCEPT:
31891 case ACCESSIBLE:
31892 case COPY:
31893 case DEFINE:
31894 case DISCONNECT:
31895 case HOST:
31896 case PRINT:
31897 case QUIT:
31898 case REMARK:
31899 case UNDEFINE:
31900 case VARIABLE:
31901 case WHENEVER:
31902 case ATTACH:
31903 case CAST:
31904 case TREAT:
31905 case TRIM:
31906 case LEFT:
31907 case RIGHT:
31908 case BOTH:
31909 case EMPTY:
31910 case MULTISET:
31911 case SUBMULTISET:
31912 case LEADING:
31913 case TRAILING:
31914 case CHAR_CS:
31915 case NCHAR_CS:
31916 case DBTIMEZONE:
31917 case SESSIONTIMEZONE:
31918 case AUTHENTICATED:
31919 case LINK:
31920 case SHARED:
31921 case DIRECTORY:
31922 case USER:
31923 KEYWORD_UNRESERVED();
31924 break;
31925 case REPLACE:
31926 jj_consume_token(REPLACE);
31927 break;
31928 case SERIALLY_REUSABLE:
31929 jj_consume_token(SERIALLY_REUSABLE);
31930 break;
31931 case RESTRICT_REFERENCES:
31932 jj_consume_token(RESTRICT_REFERENCES);
31933 break;
31934 case EXCEPTION_INIT:
31935 jj_consume_token(EXCEPTION_INIT);
31936 break;
31937 case AUTONOMOUS_TRANSACTION:
31938 jj_consume_token(AUTONOMOUS_TRANSACTION);
31939 break;
31940 case ARRAY:
31941 jj_consume_token(ARRAY);
31942 break;
31943 case AVG:
31944 jj_consume_token(AVG);
31945 break;
31946 case BINARY_INTEGER:
31947 jj_consume_token(BINARY_INTEGER);
31948 break;
31949 case BODY:
31950 jj_consume_token(BODY);
31951 break;
31952 case BOOLEAN:
31953 jj_consume_token(BOOLEAN);
31954 break;
31955 case CHAR:
31956 jj_consume_token(CHAR);
31957 break;
31958 case CHAR_BASE:
31959 jj_consume_token(CHAR_BASE);
31960 break;
31961 case CONSTANT:
31962 jj_consume_token(CONSTANT);
31963 break;
31964 case CURRVAL:
31965 jj_consume_token(CURRVAL);
31966 break;
31967 case DATE:
31968 jj_consume_token(DATE);
31969 break;
31970 case DECIMAL:
31971 jj_consume_token(DECIMAL);
31972 break;
31973 case DELETE:
31974 jj_consume_token(DELETE);
31975 break;
31976 case DO:
31977 jj_consume_token(DO);
31978 break;
31979 case ELSIF:
31980 jj_consume_token(ELSIF);
31981 break;
31982 case EXECUTE:
31983 jj_consume_token(EXECUTE);
31984 break;
31985 case EXISTS:
31986 jj_consume_token(EXISTS);
31987 break;
31988 case FLOAT:
31989 jj_consume_token(FLOAT);
31990 break;
31991 case FORALL:
31992 jj_consume_token(FORALL);
31993 break;
31994 case INTEGER:
31995 jj_consume_token(INTEGER);
31996 break;
31997 case INTERFACE:
31998 jj_consume_token(INTERFACE);
31999 break;
32000 case LONG:
32001 jj_consume_token(LONG);
32002 break;
32003 case LOOP:
32004 jj_consume_token(LOOP);
32005 break;
32006 case MOD:
32007 jj_consume_token(MOD);
32008 break;
32009 case NATURALN:
32010 jj_consume_token(NATURALN);
32011 break;
32012 case NEXTVAL:
32013 jj_consume_token(NEXTVAL);
32014 break;
32015 case NOCOPY:
32016 jj_consume_token(NOCOPY);
32017 break;
32018 case NUMBER:
32019 jj_consume_token(NUMBER);
32020 break;
32021 case BFILE_BASE:
32022 jj_consume_token(BFILE_BASE);
32023 break;
32024 case BLOB_BASE:
32025 jj_consume_token(BLOB_BASE);
32026 break;
32027 case CLOB_BASE:
32028 jj_consume_token(CLOB_BASE);
32029 break;
32030 case DATE_BASE:
32031 jj_consume_token(DATE_BASE);
32032 break;
32033 case NUMBER_BASE:
32034 jj_consume_token(NUMBER_BASE);
32035 break;
32036 case OCIROWID:
32037 jj_consume_token(OCIROWID);
32038 break;
32039 case OPERATOR:
32040 jj_consume_token(OPERATOR);
32041 break;
32042 case OUT:
32043 jj_consume_token(OUT);
32044 break;
32045 case PLS_INTEGER:
32046 jj_consume_token(PLS_INTEGER);
32047 break;
32048 case POSITIVE:
32049 jj_consume_token(POSITIVE);
32050 break;
32051 case POSITIVEN:
32052 jj_consume_token(POSITIVEN);
32053 break;
32054 case PRAGMA:
32055 jj_consume_token(PRAGMA);
32056 break;
32057 case PRIOR:
32058 jj_consume_token(PRIOR);
32059 break;
32060 case PRIVATE:
32061 jj_consume_token(PRIVATE);
32062 break;
32063 case PROMPT:
32064 jj_consume_token(PROMPT);
32065 break;
32066 case RAISE:
32067 jj_consume_token(RAISE);
32068 break;
32069 case RAW:
32070 jj_consume_token(RAW);
32071 break;
32072 case ROWTYPE:
32073 jj_consume_token(ROWTYPE);
32074 break;
32075 case SEPARATE:
32076 jj_consume_token(SEPARATE);
32077 break;
32078 case SMALLINT:
32079 jj_consume_token(SMALLINT);
32080 break;
32081 case SQLCODE:
32082 jj_consume_token(SQLCODE);
32083 break;
32084 case SQLERRM:
32085 jj_consume_token(SQLERRM);
32086 break;
32087 case STDDEV:
32088 jj_consume_token(STDDEV);
32089 break;
32090 case SUM:
32091 jj_consume_token(SUM);
32092 break;
32093 case SYNONYM:
32094 jj_consume_token(SYNONYM);
32095 break;
32096 case SYSDATE:
32097 jj_consume_token(SYSDATE);
32098 break;
32099 case TRIGGER:
32100 jj_consume_token(TRIGGER);
32101 break;
32102 case TYPE:
32103 jj_consume_token(TYPE);
32104 break;
32105 case UI:
32106 jj_consume_token(UI);
32107 break;
32108 case VARCHAR:
32109 jj_consume_token(VARCHAR);
32110 break;
32111 case VARCHAR2:
32112 jj_consume_token(VARCHAR2);
32113 break;
32114 case INT:
32115 jj_consume_token(INT);
32116 break;
32117 case SIGNTYPE:
32118 jj_consume_token(SIGNTYPE);
32119 break;
32120 case STRING:
32121 jj_consume_token(STRING);
32122 break;
32123 case WHILE:
32124 jj_consume_token(WHILE);
32125 break;
32126 default:
32127 jj_la1[455] = jj_gen;
32128 jj_consume_token(-1);
32129 throw new ParseException();
32130 }
32131 jjtree.closeNodeScope(jjtn000, true);
32132 jjtc000 = false;
32133 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
32134 } catch (Throwable jjte000) {
32135 if (jjtc000) {
32136 jjtree.clearNodeScope(jjtn000);
32137 jjtc000 = false;
32138 } else {
32139 jjtree.popNode();
32140 }
32141 if (jjte000 instanceof RuntimeException) {
32142 {if (true) throw (RuntimeException)jjte000;}
32143 }
32144 if (jjte000 instanceof ParseException) {
32145 {if (true) throw (ParseException)jjte000;}
32146 }
32147 {if (true) throw (Error)jjte000;}
32148 } finally {
32149 if (jjtc000) {
32150 jjtree.closeNodeScope(jjtn000, true);
32151 }
32152 }
32153 throw new Error("Missing return statement in function");
32154 }
32155
32156 final public ASTTypeKeyword TypeKeyword() throws ParseException {
32157
32158 ASTTypeKeyword jjtn000 = new ASTTypeKeyword(this, JJTTYPEKEYWORD);
32159 boolean jjtc000 = true;
32160 jjtree.openNodeScope(jjtn000);
32161 try {
32162 switch (jj_nt.kind) {
32163 case BFILE_BASE:
32164 jj_consume_token(BFILE_BASE);
32165 break;
32166 case BLOB_BASE:
32167 jj_consume_token(BLOB_BASE);
32168 break;
32169 case CLOB_BASE:
32170 jj_consume_token(CLOB_BASE);
32171 break;
32172 case DATE_BASE:
32173 jj_consume_token(DATE_BASE);
32174 break;
32175 case NUMBER_BASE:
32176 jj_consume_token(NUMBER_BASE);
32177 break;
32178 case BOOLEAN:
32179 jj_consume_token(BOOLEAN);
32180 break;
32181 case DATE:
32182 jj_consume_token(DATE);
32183 break;
32184 case NUMBER:
32185 jj_consume_token(NUMBER);
32186 break;
32187 case FLOAT:
32188 jj_consume_token(FLOAT);
32189 break;
32190 case REAL:
32191 jj_consume_token(REAL);
32192 break;
32193 case INTEGER:
32194 jj_consume_token(INTEGER);
32195 break;
32196 case INT:
32197 jj_consume_token(INT);
32198 break;
32199 case SMALLINT:
32200 jj_consume_token(SMALLINT);
32201 break;
32202 case DECIMAL:
32203 jj_consume_token(DECIMAL);
32204 break;
32205 case NUMERIC:
32206 jj_consume_token(NUMERIC);
32207 break;
32208 case DEC:
32209 jj_consume_token(DEC);
32210 break;
32211 case BINARY_INTEGER:
32212 jj_consume_token(BINARY_INTEGER);
32213 break;
32214 case NATURAL:
32215 jj_consume_token(NATURAL);
32216 break;
32217 case NATURALN:
32218 jj_consume_token(NATURALN);
32219 break;
32220 case POSITIVE:
32221 jj_consume_token(POSITIVE);
32222 break;
32223 case POSITIVEN:
32224 jj_consume_token(POSITIVEN);
32225 break;
32226 case SIGNTYPE:
32227 jj_consume_token(SIGNTYPE);
32228 break;
32229 case VARCHAR2:
32230 jj_consume_token(VARCHAR2);
32231 break;
32232 case VARCHAR:
32233 jj_consume_token(VARCHAR);
32234 break;
32235 case STRING:
32236 jj_consume_token(STRING);
32237 break;
32238 case LONG:
32239 jj_consume_token(LONG);
32240 break;
32241 case RAW:
32242 jj_consume_token(RAW);
32243 break;
32244 case ROWID:
32245 jj_consume_token(ROWID);
32246 break;
32247 case CHAR:
32248 jj_consume_token(CHAR);
32249 break;
32250 case CHARACTER:
32251 jj_consume_token(CHARACTER);
32252 break;
32253 case MLSLABEL:
32254 jj_consume_token(MLSLABEL);
32255 break;
32256 case BLOB:
32257 jj_consume_token(BLOB);
32258 break;
32259 case CLOB:
32260 jj_consume_token(CLOB);
32261 break;
32262 case BFILE:
32263 jj_consume_token(BFILE);
32264 break;
32265 case NCHAR:
32266 jj_consume_token(NCHAR);
32267 break;
32268 case NVARCHAR2:
32269 jj_consume_token(NVARCHAR2);
32270 break;
32271 case NCLOB:
32272 jj_consume_token(NCLOB);
32273 break;
32274 case PLS_INTEGER:
32275 jj_consume_token(PLS_INTEGER);
32276 break;
32277 case TIME:
32278 jj_consume_token(TIME);
32279 break;
32280 case TIMESTAMP:
32281 jj_consume_token(TIMESTAMP);
32282 break;
32283 case UROWID:
32284 jj_consume_token(UROWID);
32285 break;
32286 case ARRAY:
32287 jj_consume_token(ARRAY);
32288 break;
32289 case AUTHID:
32290 jj_consume_token(AUTHID);
32291 break;
32292 case ACCESSIBLE:
32293 jj_consume_token(ACCESSIBLE);
32294 jj_consume_token(CHAR_BASE);
32295 break;
32296 case CURRVAL:
32297 jj_consume_token(CURRVAL);
32298 break;
32299 case HOUR:
32300 jj_consume_token(HOUR);
32301 break;
32302 case INTERVAL:
32303 jj_consume_token(INTERVAL);
32304 break;
32305 case MONTH:
32306 jj_consume_token(MONTH);
32307 break;
32308 case OCIROWID:
32309 jj_consume_token(OCIROWID);
32310 break;
32311 case RECORD:
32312 jj_consume_token(RECORD);
32313 break;
32314 case REF:
32315 jj_consume_token(REF);
32316 break;
32317 case ROW:
32318 jj_consume_token(ROW);
32319 break;
32320 case ROWNUM:
32321 jj_consume_token(ROWNUM);
32322 break;
32323 case ROWTYPE:
32324 jj_consume_token(ROWTYPE);
32325 break;
32326 case SECOND:
32327 jj_consume_token(SECOND);
32328 break;
32329 case SET:
32330 jj_consume_token(SET);
32331 break;
32332 case TABLE:
32333 jj_consume_token(TABLE);
32334 break;
32335 case TIMEZONE_REGION:
32336 jj_consume_token(TIMEZONE_REGION);
32337 break;
32338 case TIMEZONE_ABBR:
32339 jj_consume_token(TIMEZONE_ABBR);
32340 break;
32341 case TIMEZONE_MINUTE:
32342 jj_consume_token(TIMEZONE_MINUTE);
32343 break;
32344 case TIMEZONE_HOUR:
32345 jj_consume_token(TIMEZONE_HOUR);
32346 break;
32347 case DOUBLE:
32348 jj_consume_token(DOUBLE);
32349 break;
32350 case PRECISION:
32351 jj_consume_token(PRECISION);
32352 break;
32353 case VARRAY:
32354 jj_consume_token(VARRAY);
32355 break;
32356 case YEAR:
32357 jj_consume_token(YEAR);
32358 break;
32359 case LOCAL:
32360 jj_consume_token(LOCAL);
32361 break;
32362 case WITH:
32363 jj_consume_token(WITH);
32364 break;
32365 case ZONE:
32366 jj_consume_token(ZONE);
32367 break;
32368 case JAVA_INTERFACE_CLASS:
32369 jj_consume_token(JAVA_INTERFACE_CLASS);
32370 break;
32371 case SQLDATA_CLASS:
32372 jj_consume_token(SQLDATA_CLASS);
32373 break;
32374 case CUSTOMDATUM_CLASS:
32375 jj_consume_token(CUSTOMDATUM_CLASS);
32376 break;
32377 case ORADATA_CLASS:
32378 jj_consume_token(ORADATA_CLASS);
32379 break;
32380 default:
32381 jj_la1[456] = jj_gen;
32382 jj_consume_token(-1);
32383 throw new ParseException();
32384 }
32385 jjtree.closeNodeScope(jjtn000, true);
32386 jjtc000 = false;
32387 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
32388 } finally {
32389 if (jjtc000) {
32390 jjtree.closeNodeScope(jjtn000, true);
32391 }
32392 }
32393 throw new Error("Missing return statement in function");
32394 }
32395
32396 final public ASTJavaInterfaceClass JavaInterfaceClass() throws ParseException {
32397
32398 ASTJavaInterfaceClass jjtn000 = new ASTJavaInterfaceClass(this, JJTJAVAINTERFACECLASS);
32399 boolean jjtc000 = true;
32400 jjtree.openNodeScope(jjtn000);
32401 try {
32402 switch (jj_nt.kind) {
32403 case SQLDATA_CLASS:
32404 jj_consume_token(SQLDATA_CLASS);
32405 break;
32406 case CUSTOMDATUM_CLASS:
32407 jj_consume_token(CUSTOMDATUM_CLASS);
32408 break;
32409 case ORADATA_CLASS:
32410 jj_consume_token(ORADATA_CLASS);
32411 break;
32412 default:
32413 jj_la1[457] = jj_gen;
32414 jj_consume_token(-1);
32415 throw new ParseException();
32416 }
32417 jjtree.closeNodeScope(jjtn000, true);
32418 jjtc000 = false;
32419 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
32420 } finally {
32421 if (jjtc000) {
32422 jjtree.closeNodeScope(jjtn000, true);
32423 }
32424 }
32425 throw new Error("Missing return statement in function");
32426 }
32427
32428
32429
32430
32431
32432
32433
32434 final public PLSQLNode EqualsOldIDNewID(PLSQLNode pOldID) throws ParseException {
32435
32436 ASTEqualsOldIDNewID jjtn000 = new ASTEqualsOldIDNewID(this, JJTEQUALSOLDIDNEWID);
32437 boolean jjtc000 = true;
32438 jjtree.openNodeScope(jjtn000);PLSQLNode newID;
32439 Token oldIDToken;
32440 Token newIDToken;
32441 try {
32442 newID = ID();
32443 jjtree.closeNodeScope(jjtn000, true);
32444 jjtc000 = false;
32445 oldIDToken = (Token) ((AbstractPLSQLNode)pOldID).value ;
32446 newIDToken = (Token) ((AbstractPLSQLNode)newID).value ;
32447 if (oldIDToken.image.equals(newIDToken.image)) {
32448 {if (true) return newID;}
32449 } else {
32450 {if (true) throw new ParseException("PLSQL syntax error on line "+newIDToken.beginLine+" at column "+newIDToken.beginColumn+"!\u005cn"
32451 + "Found \u005c""+newIDToken.image+"\u005c" but expected \u005c""+oldIDToken.image+"\u005c".");}
32452 }
32453 } catch (Throwable jjte000) {
32454 if (jjtc000) {
32455 jjtree.clearNodeScope(jjtn000);
32456 jjtc000 = false;
32457 } else {
32458 jjtree.popNode();
32459 }
32460 if (jjte000 instanceof RuntimeException) {
32461 {if (true) throw (RuntimeException)jjte000;}
32462 }
32463 if (jjte000 instanceof ParseException) {
32464 {if (true) throw (ParseException)jjte000;}
32465 }
32466 {if (true) throw (Error)jjte000;}
32467 } finally {
32468 if (jjtc000) {
32469 jjtree.closeNodeScope(jjtn000, true);
32470 }
32471 }
32472 throw new Error("Missing return statement in function");
32473 }
32474
32475 private boolean jj_2_1(int xla) {
32476 jj_la = xla; jj_lastpos = jj_scanpos = token;
32477 try { return !jj_3_1(); }
32478 catch(LookaheadSuccess ls) { return true; }
32479 finally { jj_save(0, xla); }
32480 }
32481
32482 private boolean jj_2_2(int xla) {
32483 jj_la = xla; jj_lastpos = jj_scanpos = token;
32484 try { return !jj_3_2(); }
32485 catch(LookaheadSuccess ls) { return true; }
32486 finally { jj_save(1, xla); }
32487 }
32488
32489 private boolean jj_2_3(int xla) {
32490 jj_la = xla; jj_lastpos = jj_scanpos = token;
32491 try { return !jj_3_3(); }
32492 catch(LookaheadSuccess ls) { return true; }
32493 finally { jj_save(2, xla); }
32494 }
32495
32496 private boolean jj_2_4(int xla) {
32497 jj_la = xla; jj_lastpos = jj_scanpos = token;
32498 try { return !jj_3_4(); }
32499 catch(LookaheadSuccess ls) { return true; }
32500 finally { jj_save(3, xla); }
32501 }
32502
32503 private boolean jj_2_5(int xla) {
32504 jj_la = xla; jj_lastpos = jj_scanpos = token;
32505 try { return !jj_3_5(); }
32506 catch(LookaheadSuccess ls) { return true; }
32507 finally { jj_save(4, xla); }
32508 }
32509
32510 private boolean jj_2_6(int xla) {
32511 jj_la = xla; jj_lastpos = jj_scanpos = token;
32512 try { return !jj_3_6(); }
32513 catch(LookaheadSuccess ls) { return true; }
32514 finally { jj_save(5, xla); }
32515 }
32516
32517 private boolean jj_2_7(int xla) {
32518 jj_la = xla; jj_lastpos = jj_scanpos = token;
32519 try { return !jj_3_7(); }
32520 catch(LookaheadSuccess ls) { return true; }
32521 finally { jj_save(6, xla); }
32522 }
32523
32524 private boolean jj_2_8(int xla) {
32525 jj_la = xla; jj_lastpos = jj_scanpos = token;
32526 try { return !jj_3_8(); }
32527 catch(LookaheadSuccess ls) { return true; }
32528 finally { jj_save(7, xla); }
32529 }
32530
32531 private boolean jj_2_9(int xla) {
32532 jj_la = xla; jj_lastpos = jj_scanpos = token;
32533 try { return !jj_3_9(); }
32534 catch(LookaheadSuccess ls) { return true; }
32535 finally { jj_save(8, xla); }
32536 }
32537
32538 private boolean jj_2_10(int xla) {
32539 jj_la = xla; jj_lastpos = jj_scanpos = token;
32540 try { return !jj_3_10(); }
32541 catch(LookaheadSuccess ls) { return true; }
32542 finally { jj_save(9, xla); }
32543 }
32544
32545 private boolean jj_2_11(int xla) {
32546 jj_la = xla; jj_lastpos = jj_scanpos = token;
32547 try { return !jj_3_11(); }
32548 catch(LookaheadSuccess ls) { return true; }
32549 finally { jj_save(10, xla); }
32550 }
32551
32552 private boolean jj_2_12(int xla) {
32553 jj_la = xla; jj_lastpos = jj_scanpos = token;
32554 try { return !jj_3_12(); }
32555 catch(LookaheadSuccess ls) { return true; }
32556 finally { jj_save(11, xla); }
32557 }
32558
32559 private boolean jj_2_13(int xla) {
32560 jj_la = xla; jj_lastpos = jj_scanpos = token;
32561 try { return !jj_3_13(); }
32562 catch(LookaheadSuccess ls) { return true; }
32563 finally { jj_save(12, xla); }
32564 }
32565
32566 private boolean jj_2_14(int xla) {
32567 jj_la = xla; jj_lastpos = jj_scanpos = token;
32568 try { return !jj_3_14(); }
32569 catch(LookaheadSuccess ls) { return true; }
32570 finally { jj_save(13, xla); }
32571 }
32572
32573 private boolean jj_2_15(int xla) {
32574 jj_la = xla; jj_lastpos = jj_scanpos = token;
32575 try { return !jj_3_15(); }
32576 catch(LookaheadSuccess ls) { return true; }
32577 finally { jj_save(14, xla); }
32578 }
32579
32580 private boolean jj_2_16(int xla) {
32581 jj_la = xla; jj_lastpos = jj_scanpos = token;
32582 try { return !jj_3_16(); }
32583 catch(LookaheadSuccess ls) { return true; }
32584 finally { jj_save(15, xla); }
32585 }
32586
32587 private boolean jj_2_17(int xla) {
32588 jj_la = xla; jj_lastpos = jj_scanpos = token;
32589 try { return !jj_3_17(); }
32590 catch(LookaheadSuccess ls) { return true; }
32591 finally { jj_save(16, xla); }
32592 }
32593
32594 private boolean jj_2_18(int xla) {
32595 jj_la = xla; jj_lastpos = jj_scanpos = token;
32596 try { return !jj_3_18(); }
32597 catch(LookaheadSuccess ls) { return true; }
32598 finally { jj_save(17, xla); }
32599 }
32600
32601 private boolean jj_2_19(int xla) {
32602 jj_la = xla; jj_lastpos = jj_scanpos = token;
32603 try { return !jj_3_19(); }
32604 catch(LookaheadSuccess ls) { return true; }
32605 finally { jj_save(18, xla); }
32606 }
32607
32608 private boolean jj_2_20(int xla) {
32609 jj_la = xla; jj_lastpos = jj_scanpos = token;
32610 try { return !jj_3_20(); }
32611 catch(LookaheadSuccess ls) { return true; }
32612 finally { jj_save(19, xla); }
32613 }
32614
32615 private boolean jj_2_21(int xla) {
32616 jj_la = xla; jj_lastpos = jj_scanpos = token;
32617 try { return !jj_3_21(); }
32618 catch(LookaheadSuccess ls) { return true; }
32619 finally { jj_save(20, xla); }
32620 }
32621
32622 private boolean jj_2_22(int xla) {
32623 jj_la = xla; jj_lastpos = jj_scanpos = token;
32624 try { return !jj_3_22(); }
32625 catch(LookaheadSuccess ls) { return true; }
32626 finally { jj_save(21, xla); }
32627 }
32628
32629 private boolean jj_2_23(int xla) {
32630 jj_la = xla; jj_lastpos = jj_scanpos = token;
32631 try { return !jj_3_23(); }
32632 catch(LookaheadSuccess ls) { return true; }
32633 finally { jj_save(22, xla); }
32634 }
32635
32636 private boolean jj_2_24(int xla) {
32637 jj_la = xla; jj_lastpos = jj_scanpos = token;
32638 try { return !jj_3_24(); }
32639 catch(LookaheadSuccess ls) { return true; }
32640 finally { jj_save(23, xla); }
32641 }
32642
32643 private boolean jj_2_25(int xla) {
32644 jj_la = xla; jj_lastpos = jj_scanpos = token;
32645 try { return !jj_3_25(); }
32646 catch(LookaheadSuccess ls) { return true; }
32647 finally { jj_save(24, xla); }
32648 }
32649
32650 private boolean jj_2_26(int xla) {
32651 jj_la = xla; jj_lastpos = jj_scanpos = token;
32652 try { return !jj_3_26(); }
32653 catch(LookaheadSuccess ls) { return true; }
32654 finally { jj_save(25, xla); }
32655 }
32656
32657 private boolean jj_2_27(int xla) {
32658 jj_la = xla; jj_lastpos = jj_scanpos = token;
32659 try { return !jj_3_27(); }
32660 catch(LookaheadSuccess ls) { return true; }
32661 finally { jj_save(26, xla); }
32662 }
32663
32664 private boolean jj_2_28(int xla) {
32665 jj_la = xla; jj_lastpos = jj_scanpos = token;
32666 try { return !jj_3_28(); }
32667 catch(LookaheadSuccess ls) { return true; }
32668 finally { jj_save(27, xla); }
32669 }
32670
32671 private boolean jj_2_29(int xla) {
32672 jj_la = xla; jj_lastpos = jj_scanpos = token;
32673 try { return !jj_3_29(); }
32674 catch(LookaheadSuccess ls) { return true; }
32675 finally { jj_save(28, xla); }
32676 }
32677
32678 private boolean jj_2_30(int xla) {
32679 jj_la = xla; jj_lastpos = jj_scanpos = token;
32680 try { return !jj_3_30(); }
32681 catch(LookaheadSuccess ls) { return true; }
32682 finally { jj_save(29, xla); }
32683 }
32684
32685 private boolean jj_2_31(int xla) {
32686 jj_la = xla; jj_lastpos = jj_scanpos = token;
32687 try { return !jj_3_31(); }
32688 catch(LookaheadSuccess ls) { return true; }
32689 finally { jj_save(30, xla); }
32690 }
32691
32692 private boolean jj_2_32(int xla) {
32693 jj_la = xla; jj_lastpos = jj_scanpos = token;
32694 try { return !jj_3_32(); }
32695 catch(LookaheadSuccess ls) { return true; }
32696 finally { jj_save(31, xla); }
32697 }
32698
32699 private boolean jj_2_33(int xla) {
32700 jj_la = xla; jj_lastpos = jj_scanpos = token;
32701 try { return !jj_3_33(); }
32702 catch(LookaheadSuccess ls) { return true; }
32703 finally { jj_save(32, xla); }
32704 }
32705
32706 private boolean jj_2_34(int xla) {
32707 jj_la = xla; jj_lastpos = jj_scanpos = token;
32708 try { return !jj_3_34(); }
32709 catch(LookaheadSuccess ls) { return true; }
32710 finally { jj_save(33, xla); }
32711 }
32712
32713 private boolean jj_2_35(int xla) {
32714 jj_la = xla; jj_lastpos = jj_scanpos = token;
32715 try { return !jj_3_35(); }
32716 catch(LookaheadSuccess ls) { return true; }
32717 finally { jj_save(34, xla); }
32718 }
32719
32720 private boolean jj_2_36(int xla) {
32721 jj_la = xla; jj_lastpos = jj_scanpos = token;
32722 try { return !jj_3_36(); }
32723 catch(LookaheadSuccess ls) { return true; }
32724 finally { jj_save(35, xla); }
32725 }
32726
32727 private boolean jj_2_37(int xla) {
32728 jj_la = xla; jj_lastpos = jj_scanpos = token;
32729 try { return !jj_3_37(); }
32730 catch(LookaheadSuccess ls) { return true; }
32731 finally { jj_save(36, xla); }
32732 }
32733
32734 private boolean jj_2_38(int xla) {
32735 jj_la = xla; jj_lastpos = jj_scanpos = token;
32736 try { return !jj_3_38(); }
32737 catch(LookaheadSuccess ls) { return true; }
32738 finally { jj_save(37, xla); }
32739 }
32740
32741 private boolean jj_2_39(int xla) {
32742 jj_la = xla; jj_lastpos = jj_scanpos = token;
32743 try { return !jj_3_39(); }
32744 catch(LookaheadSuccess ls) { return true; }
32745 finally { jj_save(38, xla); }
32746 }
32747
32748 private boolean jj_2_40(int xla) {
32749 jj_la = xla; jj_lastpos = jj_scanpos = token;
32750 try { return !jj_3_40(); }
32751 catch(LookaheadSuccess ls) { return true; }
32752 finally { jj_save(39, xla); }
32753 }
32754
32755 private boolean jj_2_41(int xla) {
32756 jj_la = xla; jj_lastpos = jj_scanpos = token;
32757 try { return !jj_3_41(); }
32758 catch(LookaheadSuccess ls) { return true; }
32759 finally { jj_save(40, xla); }
32760 }
32761
32762 private boolean jj_2_42(int xla) {
32763 jj_la = xla; jj_lastpos = jj_scanpos = token;
32764 try { return !jj_3_42(); }
32765 catch(LookaheadSuccess ls) { return true; }
32766 finally { jj_save(41, xla); }
32767 }
32768
32769 private boolean jj_2_43(int xla) {
32770 jj_la = xla; jj_lastpos = jj_scanpos = token;
32771 try { return !jj_3_43(); }
32772 catch(LookaheadSuccess ls) { return true; }
32773 finally { jj_save(42, xla); }
32774 }
32775
32776 private boolean jj_2_44(int xla) {
32777 jj_la = xla; jj_lastpos = jj_scanpos = token;
32778 try { return !jj_3_44(); }
32779 catch(LookaheadSuccess ls) { return true; }
32780 finally { jj_save(43, xla); }
32781 }
32782
32783 private boolean jj_2_45(int xla) {
32784 jj_la = xla; jj_lastpos = jj_scanpos = token;
32785 try { return !jj_3_45(); }
32786 catch(LookaheadSuccess ls) { return true; }
32787 finally { jj_save(44, xla); }
32788 }
32789
32790 private boolean jj_2_46(int xla) {
32791 jj_la = xla; jj_lastpos = jj_scanpos = token;
32792 try { return !jj_3_46(); }
32793 catch(LookaheadSuccess ls) { return true; }
32794 finally { jj_save(45, xla); }
32795 }
32796
32797 private boolean jj_2_47(int xla) {
32798 jj_la = xla; jj_lastpos = jj_scanpos = token;
32799 try { return !jj_3_47(); }
32800 catch(LookaheadSuccess ls) { return true; }
32801 finally { jj_save(46, xla); }
32802 }
32803
32804 private boolean jj_2_48(int xla) {
32805 jj_la = xla; jj_lastpos = jj_scanpos = token;
32806 try { return !jj_3_48(); }
32807 catch(LookaheadSuccess ls) { return true; }
32808 finally { jj_save(47, xla); }
32809 }
32810
32811 private boolean jj_2_49(int xla) {
32812 jj_la = xla; jj_lastpos = jj_scanpos = token;
32813 try { return !jj_3_49(); }
32814 catch(LookaheadSuccess ls) { return true; }
32815 finally { jj_save(48, xla); }
32816 }
32817
32818 private boolean jj_2_50(int xla) {
32819 jj_la = xla; jj_lastpos = jj_scanpos = token;
32820 try { return !jj_3_50(); }
32821 catch(LookaheadSuccess ls) { return true; }
32822 finally { jj_save(49, xla); }
32823 }
32824
32825 private boolean jj_2_51(int xla) {
32826 jj_la = xla; jj_lastpos = jj_scanpos = token;
32827 try { return !jj_3_51(); }
32828 catch(LookaheadSuccess ls) { return true; }
32829 finally { jj_save(50, xla); }
32830 }
32831
32832 private boolean jj_2_52(int xla) {
32833 jj_la = xla; jj_lastpos = jj_scanpos = token;
32834 try { return !jj_3_52(); }
32835 catch(LookaheadSuccess ls) { return true; }
32836 finally { jj_save(51, xla); }
32837 }
32838
32839 private boolean jj_2_53(int xla) {
32840 jj_la = xla; jj_lastpos = jj_scanpos = token;
32841 try { return !jj_3_53(); }
32842 catch(LookaheadSuccess ls) { return true; }
32843 finally { jj_save(52, xla); }
32844 }
32845
32846 private boolean jj_2_54(int xla) {
32847 jj_la = xla; jj_lastpos = jj_scanpos = token;
32848 try { return !jj_3_54(); }
32849 catch(LookaheadSuccess ls) { return true; }
32850 finally { jj_save(53, xla); }
32851 }
32852
32853 private boolean jj_2_55(int xla) {
32854 jj_la = xla; jj_lastpos = jj_scanpos = token;
32855 try { return !jj_3_55(); }
32856 catch(LookaheadSuccess ls) { return true; }
32857 finally { jj_save(54, xla); }
32858 }
32859
32860 private boolean jj_2_56(int xla) {
32861 jj_la = xla; jj_lastpos = jj_scanpos = token;
32862 try { return !jj_3_56(); }
32863 catch(LookaheadSuccess ls) { return true; }
32864 finally { jj_save(55, xla); }
32865 }
32866
32867 private boolean jj_2_57(int xla) {
32868 jj_la = xla; jj_lastpos = jj_scanpos = token;
32869 try { return !jj_3_57(); }
32870 catch(LookaheadSuccess ls) { return true; }
32871 finally { jj_save(56, xla); }
32872 }
32873
32874 private boolean jj_2_58(int xla) {
32875 jj_la = xla; jj_lastpos = jj_scanpos = token;
32876 try { return !jj_3_58(); }
32877 catch(LookaheadSuccess ls) { return true; }
32878 finally { jj_save(57, xla); }
32879 }
32880
32881 private boolean jj_2_59(int xla) {
32882 jj_la = xla; jj_lastpos = jj_scanpos = token;
32883 try { return !jj_3_59(); }
32884 catch(LookaheadSuccess ls) { return true; }
32885 finally { jj_save(58, xla); }
32886 }
32887
32888 private boolean jj_2_60(int xla) {
32889 jj_la = xla; jj_lastpos = jj_scanpos = token;
32890 try { return !jj_3_60(); }
32891 catch(LookaheadSuccess ls) { return true; }
32892 finally { jj_save(59, xla); }
32893 }
32894
32895 private boolean jj_2_61(int xla) {
32896 jj_la = xla; jj_lastpos = jj_scanpos = token;
32897 try { return !jj_3_61(); }
32898 catch(LookaheadSuccess ls) { return true; }
32899 finally { jj_save(60, xla); }
32900 }
32901
32902 private boolean jj_2_62(int xla) {
32903 jj_la = xla; jj_lastpos = jj_scanpos = token;
32904 try { return !jj_3_62(); }
32905 catch(LookaheadSuccess ls) { return true; }
32906 finally { jj_save(61, xla); }
32907 }
32908
32909 private boolean jj_2_63(int xla) {
32910 jj_la = xla; jj_lastpos = jj_scanpos = token;
32911 try { return !jj_3_63(); }
32912 catch(LookaheadSuccess ls) { return true; }
32913 finally { jj_save(62, xla); }
32914 }
32915
32916 private boolean jj_2_64(int xla) {
32917 jj_la = xla; jj_lastpos = jj_scanpos = token;
32918 try { return !jj_3_64(); }
32919 catch(LookaheadSuccess ls) { return true; }
32920 finally { jj_save(63, xla); }
32921 }
32922
32923 private boolean jj_2_65(int xla) {
32924 jj_la = xla; jj_lastpos = jj_scanpos = token;
32925 try { return !jj_3_65(); }
32926 catch(LookaheadSuccess ls) { return true; }
32927 finally { jj_save(64, xla); }
32928 }
32929
32930 private boolean jj_2_66(int xla) {
32931 jj_la = xla; jj_lastpos = jj_scanpos = token;
32932 try { return !jj_3_66(); }
32933 catch(LookaheadSuccess ls) { return true; }
32934 finally { jj_save(65, xla); }
32935 }
32936
32937 private boolean jj_2_67(int xla) {
32938 jj_la = xla; jj_lastpos = jj_scanpos = token;
32939 try { return !jj_3_67(); }
32940 catch(LookaheadSuccess ls) { return true; }
32941 finally { jj_save(66, xla); }
32942 }
32943
32944 private boolean jj_2_68(int xla) {
32945 jj_la = xla; jj_lastpos = jj_scanpos = token;
32946 try { return !jj_3_68(); }
32947 catch(LookaheadSuccess ls) { return true; }
32948 finally { jj_save(67, xla); }
32949 }
32950
32951 private boolean jj_2_69(int xla) {
32952 jj_la = xla; jj_lastpos = jj_scanpos = token;
32953 try { return !jj_3_69(); }
32954 catch(LookaheadSuccess ls) { return true; }
32955 finally { jj_save(68, xla); }
32956 }
32957
32958 private boolean jj_2_70(int xla) {
32959 jj_la = xla; jj_lastpos = jj_scanpos = token;
32960 try { return !jj_3_70(); }
32961 catch(LookaheadSuccess ls) { return true; }
32962 finally { jj_save(69, xla); }
32963 }
32964
32965 private boolean jj_2_71(int xla) {
32966 jj_la = xla; jj_lastpos = jj_scanpos = token;
32967 try { return !jj_3_71(); }
32968 catch(LookaheadSuccess ls) { return true; }
32969 finally { jj_save(70, xla); }
32970 }
32971
32972 private boolean jj_2_72(int xla) {
32973 jj_la = xla; jj_lastpos = jj_scanpos = token;
32974 try { return !jj_3_72(); }
32975 catch(LookaheadSuccess ls) { return true; }
32976 finally { jj_save(71, xla); }
32977 }
32978
32979 private boolean jj_2_73(int xla) {
32980 jj_la = xla; jj_lastpos = jj_scanpos = token;
32981 try { return !jj_3_73(); }
32982 catch(LookaheadSuccess ls) { return true; }
32983 finally { jj_save(72, xla); }
32984 }
32985
32986 private boolean jj_2_74(int xla) {
32987 jj_la = xla; jj_lastpos = jj_scanpos = token;
32988 try { return !jj_3_74(); }
32989 catch(LookaheadSuccess ls) { return true; }
32990 finally { jj_save(73, xla); }
32991 }
32992
32993 private boolean jj_2_75(int xla) {
32994 jj_la = xla; jj_lastpos = jj_scanpos = token;
32995 try { return !jj_3_75(); }
32996 catch(LookaheadSuccess ls) { return true; }
32997 finally { jj_save(74, xla); }
32998 }
32999
33000 private boolean jj_2_76(int xla) {
33001 jj_la = xla; jj_lastpos = jj_scanpos = token;
33002 try { return !jj_3_76(); }
33003 catch(LookaheadSuccess ls) { return true; }
33004 finally { jj_save(75, xla); }
33005 }
33006
33007 private boolean jj_2_77(int xla) {
33008 jj_la = xla; jj_lastpos = jj_scanpos = token;
33009 try { return !jj_3_77(); }
33010 catch(LookaheadSuccess ls) { return true; }
33011 finally { jj_save(76, xla); }
33012 }
33013
33014 private boolean jj_2_78(int xla) {
33015 jj_la = xla; jj_lastpos = jj_scanpos = token;
33016 try { return !jj_3_78(); }
33017 catch(LookaheadSuccess ls) { return true; }
33018 finally { jj_save(77, xla); }
33019 }
33020
33021 private boolean jj_2_79(int xla) {
33022 jj_la = xla; jj_lastpos = jj_scanpos = token;
33023 try { return !jj_3_79(); }
33024 catch(LookaheadSuccess ls) { return true; }
33025 finally { jj_save(78, xla); }
33026 }
33027
33028 private boolean jj_2_80(int xla) {
33029 jj_la = xla; jj_lastpos = jj_scanpos = token;
33030 try { return !jj_3_80(); }
33031 catch(LookaheadSuccess ls) { return true; }
33032 finally { jj_save(79, xla); }
33033 }
33034
33035 private boolean jj_2_81(int xla) {
33036 jj_la = xla; jj_lastpos = jj_scanpos = token;
33037 try { return !jj_3_81(); }
33038 catch(LookaheadSuccess ls) { return true; }
33039 finally { jj_save(80, xla); }
33040 }
33041
33042 private boolean jj_2_82(int xla) {
33043 jj_la = xla; jj_lastpos = jj_scanpos = token;
33044 try { return !jj_3_82(); }
33045 catch(LookaheadSuccess ls) { return true; }
33046 finally { jj_save(81, xla); }
33047 }
33048
33049 private boolean jj_2_83(int xla) {
33050 jj_la = xla; jj_lastpos = jj_scanpos = token;
33051 try { return !jj_3_83(); }
33052 catch(LookaheadSuccess ls) { return true; }
33053 finally { jj_save(82, xla); }
33054 }
33055
33056 private boolean jj_2_84(int xla) {
33057 jj_la = xla; jj_lastpos = jj_scanpos = token;
33058 try { return !jj_3_84(); }
33059 catch(LookaheadSuccess ls) { return true; }
33060 finally { jj_save(83, xla); }
33061 }
33062
33063 private boolean jj_3R_287() {
33064 if (jj_scan_token(NAME)) return true;
33065 Token xsp;
33066 xsp = jj_scanpos;
33067 if (jj_scan_token(420)) {
33068 jj_scanpos = xsp;
33069 if (jj_scan_token(428)) {
33070 jj_scanpos = xsp;
33071 if (jj_3R_562()) return true;
33072 }
33073 }
33074 return false;
33075 }
33076
33077 private boolean jj_3R_527() {
33078 if (jj_scan_token(INDEX)) return true;
33079 if (jj_scan_token(BY)) return true;
33080 if (jj_3R_235()) return true;
33081 return false;
33082 }
33083
33084 private boolean jj_3R_523() {
33085 if (jj_scan_token(6)) return true;
33086 if (jj_3R_521()) return true;
33087 return false;
33088 }
33089
33090 private boolean jj_3R_200() {
33091 Token xsp;
33092 xsp = jj_scanpos;
33093 if (jj_3R_286()) {
33094 jj_scanpos = xsp;
33095 if (jj_3R_287()) {
33096 jj_scanpos = xsp;
33097 if (jj_3R_288()) {
33098 jj_scanpos = xsp;
33099 if (jj_3R_289()) return true;
33100 }
33101 }
33102 }
33103 return false;
33104 }
33105
33106 private boolean jj_3R_286() {
33107 if (jj_scan_token(LIBRARY)) return true;
33108 Token xsp;
33109 xsp = jj_scanpos;
33110 if (jj_scan_token(420)) {
33111 jj_scanpos = xsp;
33112 if (jj_scan_token(428)) {
33113 jj_scanpos = xsp;
33114 if (jj_3R_561()) return true;
33115 }
33116 }
33117 xsp = jj_scanpos;
33118 if (jj_3R_629()) jj_scanpos = xsp;
33119 return false;
33120 }
33121
33122 private boolean jj_3_73() {
33123 if (jj_scan_token(OF)) return true;
33124 if (jj_3R_124()) return true;
33125 Token xsp;
33126 while (true) {
33127 xsp = jj_scanpos;
33128 if (jj_3R_150()) { jj_scanpos = xsp; break; }
33129 }
33130 return false;
33131 }
33132
33133 private boolean jj_3R_522() {
33134 if (jj_scan_token(6)) return true;
33135 if (jj_3R_521()) return true;
33136 return false;
33137 }
33138
33139 private boolean jj_3R_199() {
33140 if (jj_scan_token(LANGUAGE)) return true;
33141 Token xsp;
33142 xsp = jj_scanpos;
33143 if (jj_scan_token(420)) {
33144 jj_scanpos = xsp;
33145 if (jj_scan_token(154)) return true;
33146 }
33147 return false;
33148 }
33149
33150 private boolean jj_3R_564() {
33151 Token xsp;
33152 xsp = jj_scanpos;
33153 if (jj_scan_token(183)) jj_scanpos = xsp;
33154 if (jj_scan_token(NULL)) return true;
33155 return false;
33156 }
33157
33158 private boolean jj_3R_529() {
33159 if (jj_scan_token(6)) return true;
33160 if (jj_3R_233()) return true;
33161 return false;
33162 }
33163
33164 private boolean jj_3R_524() {
33165 if (jj_scan_token(VARYING)) return true;
33166 if (jj_scan_token(ARRAY)) return true;
33167 return false;
33168 }
33169
33170 private boolean jj_3R_528() {
33171 if (jj_scan_token(RETURN)) return true;
33172 if (jj_3R_235()) return true;
33173 return false;
33174 }
33175
33176 private boolean jj_3R_526() {
33177 if (jj_scan_token(NOT)) return true;
33178 if (jj_scan_token(NULL)) return true;
33179 return false;
33180 }
33181
33182 private boolean jj_3R_266() {
33183 Token xsp;
33184 xsp = jj_scanpos;
33185 if (jj_scan_token(100)) {
33186 jj_scanpos = xsp;
33187 if (jj_scan_token(182)) return true;
33188 }
33189 return false;
33190 }
33191
33192 private boolean jj_3R_123() {
33193 Token xsp;
33194 xsp = jj_scanpos;
33195 if (jj_scan_token(114)) {
33196 jj_scanpos = xsp;
33197 if (jj_3R_199()) return true;
33198 }
33199 while (true) {
33200 xsp = jj_scanpos;
33201 if (jj_3R_200()) { jj_scanpos = xsp; break; }
33202 }
33203 return false;
33204 }
33205
33206 private boolean jj_3R_498() {
33207 if (jj_3R_235()) return true;
33208 return false;
33209 }
33210
33211 private boolean jj_3R_497() {
33212 if (jj_scan_token(5)) return true;
33213 if (jj_3R_233()) return true;
33214 Token xsp;
33215 while (true) {
33216 xsp = jj_scanpos;
33217 if (jj_3R_529()) { jj_scanpos = xsp; break; }
33218 }
33219 if (jj_scan_token(7)) return true;
33220 return false;
33221 }
33222
33223 private boolean jj_3R_268() {
33224 Token xsp;
33225 xsp = jj_scanpos;
33226 if (jj_scan_token(93)) {
33227 jj_scanpos = xsp;
33228 if (jj_scan_token(144)) {
33229 jj_scanpos = xsp;
33230 if (jj_scan_token(297)) return true;
33231 }
33232 }
33233 return false;
33234 }
33235
33236 private boolean jj_3_76() {
33237 if (jj_3R_124()) return true;
33238 if (jj_scan_token(3)) return true;
33239 return false;
33240 }
33241
33242 private boolean jj_3R_178() {
33243 Token xsp;
33244 xsp = jj_scanpos;
33245 if (jj_3_76()) jj_scanpos = xsp;
33246 if (jj_3R_124()) return true;
33247 return false;
33248 }
33249
33250 private boolean jj_3_77() {
33251 if (jj_scan_token(NESTED)) return true;
33252 if (jj_scan_token(TABLE)) return true;
33253 return false;
33254 }
33255
33256 private boolean jj_3R_496() {
33257 if (jj_scan_token(REF)) return true;
33258 if (jj_scan_token(CURSOR)) return true;
33259 Token xsp;
33260 xsp = jj_scanpos;
33261 if (jj_3R_528()) jj_scanpos = xsp;
33262 return false;
33263 }
33264
33265 private boolean jj_3R_521() {
33266 if (jj_3R_124()) return true;
33267 if (jj_3R_235()) return true;
33268 Token xsp;
33269 xsp = jj_scanpos;
33270 if (jj_3R_564()) jj_scanpos = xsp;
33271 xsp = jj_scanpos;
33272 if (jj_3R_565()) jj_scanpos = xsp;
33273 return false;
33274 }
33275
33276 private boolean jj_3R_495() {
33277 Token xsp;
33278 xsp = jj_scanpos;
33279 if (jj_scan_token(271)) {
33280 jj_scanpos = xsp;
33281 if (jj_scan_token(310)) {
33282 jj_scanpos = xsp;
33283 if (jj_3R_524()) return true;
33284 }
33285 }
33286 xsp = jj_scanpos;
33287 if (jj_3R_525()) jj_scanpos = xsp;
33288 if (jj_scan_token(OF)) return true;
33289 if (jj_3R_235()) return true;
33290 xsp = jj_scanpos;
33291 if (jj_3R_526()) jj_scanpos = xsp;
33292 xsp = jj_scanpos;
33293 if (jj_3R_527()) jj_scanpos = xsp;
33294 return false;
33295 }
33296
33297 private boolean jj_3R_177() {
33298 if (jj_scan_token(OR)) return true;
33299 Token xsp;
33300 xsp = jj_scanpos;
33301 if (jj_3R_268()) {
33302 jj_scanpos = xsp;
33303 if (jj_3R_269()) return true;
33304 }
33305 return false;
33306 }
33307
33308 private boolean jj_3R_494() {
33309 if (jj_scan_token(RECORD)) return true;
33310 if (jj_scan_token(5)) return true;
33311 if (jj_3R_521()) return true;
33312 Token xsp;
33313 while (true) {
33314 xsp = jj_scanpos;
33315 if (jj_3R_523()) { jj_scanpos = xsp; break; }
33316 }
33317 if (jj_scan_token(7)) return true;
33318 return false;
33319 }
33320
33321 private boolean jj_3R_175() {
33322 Token xsp;
33323 xsp = jj_scanpos;
33324 if (jj_scan_token(93)) {
33325 jj_scanpos = xsp;
33326 if (jj_scan_token(144)) {
33327 jj_scanpos = xsp;
33328 if (jj_scan_token(297)) return true;
33329 }
33330 }
33331 xsp = jj_scanpos;
33332 if (jj_3_73()) jj_scanpos = xsp;
33333 return false;
33334 }
33335
33336 private boolean jj_3R_265() {
33337 if (jj_scan_token(OR)) return true;
33338 if (jj_scan_token(REPLACE)) return true;
33339 return false;
33340 }
33341
33342 private boolean jj_3R_493() {
33343 if (jj_scan_token(OBJECT)) return true;
33344 if (jj_scan_token(5)) return true;
33345 if (jj_3R_521()) return true;
33346 Token xsp;
33347 while (true) {
33348 xsp = jj_scanpos;
33349 if (jj_3R_522()) { jj_scanpos = xsp; break; }
33350 }
33351 if (jj_scan_token(7)) return true;
33352 return false;
33353 }
33354
33355 private boolean jj_3R_174() {
33356 if (jj_scan_token(CREATE)) return true;
33357 Token xsp;
33358 xsp = jj_scanpos;
33359 if (jj_3R_265()) jj_scanpos = xsp;
33360 xsp = jj_scanpos;
33361 if (jj_3R_266()) jj_scanpos = xsp;
33362 return false;
33363 }
33364
33365 private boolean jj_3R_108() {
33366 Token xsp;
33367 xsp = jj_scanpos;
33368 if (jj_3R_174()) jj_scanpos = xsp;
33369 if (jj_scan_token(TRIGGER)) return true;
33370 if (jj_3R_154()) return true;
33371 xsp = jj_scanpos;
33372 if (jj_scan_token(322)) {
33373 jj_scanpos = xsp;
33374 if (jj_scan_token(321)) {
33375 jj_scanpos = xsp;
33376 if (jj_scan_token(323)) {
33377 jj_scanpos = xsp;
33378 if (jj_scan_token(121)) return true;
33379 }
33380 }
33381 }
33382 xsp = jj_scanpos;
33383 if (jj_3R_175()) {
33384 jj_scanpos = xsp;
33385 if (jj_3R_176()) return true;
33386 }
33387 while (true) {
33388 xsp = jj_scanpos;
33389 if (jj_3R_177()) { jj_scanpos = xsp; break; }
33390 }
33391 if (jj_scan_token(ON)) return true;
33392 xsp = jj_scanpos;
33393 if (jj_scan_token(348)) {
33394 jj_scanpos = xsp;
33395 if (jj_3_77()) {
33396 jj_scanpos = xsp;
33397 if (jj_3R_178()) return true;
33398 }
33399 }
33400 return false;
33401 }
33402
33403 private boolean jj_3R_640() {
33404 if (jj_3R_173()) return true;
33405 return false;
33406 }
33407
33408 private boolean jj_3_44() {
33409 if (jj_scan_token(NEW)) return true;
33410 Token xsp;
33411 xsp = jj_scanpos;
33412 if (jj_scan_token(68)) {
33413 jj_scanpos = xsp;
33414 if (jj_scan_token(191)) {
33415 jj_scanpos = xsp;
33416 if (jj_scan_token(190)) {
33417 jj_scanpos = xsp;
33418 if (jj_scan_token(189)) {
33419 jj_scanpos = xsp;
33420 if (jj_scan_token(188)) {
33421 jj_scanpos = xsp;
33422 if (jj_scan_token(192)) return true;
33423 }
33424 }
33425 }
33426 }
33427 }
33428 return false;
33429 }
33430
33431 private boolean jj_3R_594() {
33432 if (jj_3R_173()) return true;
33433 return false;
33434 }
33435
33436 private boolean jj_3R_641() {
33437 Token xsp;
33438 xsp = jj_scanpos;
33439 if (jj_scan_token(137)) {
33440 jj_scanpos = xsp;
33441 if (jj_scan_token(207)) {
33442 jj_scanpos = xsp;
33443 if (jj_scan_token(138)) return true;
33444 }
33445 }
33446 return false;
33447 }
33448
33449 private boolean jj_3R_492() {
33450 if (jj_scan_token(NOT)) return true;
33451 if (jj_scan_token(NULL)) return true;
33452 return false;
33453 }
33454
33455 private boolean jj_3R_520() {
33456 if (jj_scan_token(RANGE)) return true;
33457 if (jj_3R_483()) return true;
33458 if (jj_scan_token(12)) return true;
33459 if (jj_3R_483()) return true;
33460 return false;
33461 }
33462
33463 private boolean jj_3R_519() {
33464 if (jj_scan_token(5)) return true;
33465 if (jj_scan_token(IDENTIFIER)) return true;
33466 if (jj_scan_token(7)) return true;
33467 return false;
33468 }
33469
33470 private boolean jj_3R_491() {
33471 Token xsp;
33472 xsp = jj_scanpos;
33473 if (jj_3R_519()) {
33474 jj_scanpos = xsp;
33475 if (jj_3R_520()) return true;
33476 }
33477 return false;
33478 }
33479
33480 private boolean jj_3R_642() {
33481 if (jj_scan_token(IN)) return true;
33482 Token xsp;
33483 xsp = jj_scanpos;
33484 if (jj_scan_token(207)) jj_scanpos = xsp;
33485 return false;
33486 }
33487
33488 private boolean jj_3R_639() {
33489 Token xsp;
33490 xsp = jj_scanpos;
33491 if (jj_3R_642()) {
33492 jj_scanpos = xsp;
33493 if (jj_scan_token(207)) return true;
33494 }
33495 return false;
33496 }
33497
33498 private boolean jj_3R_638() {
33499 if (jj_scan_token(6)) return true;
33500 Token xsp;
33501 xsp = jj_scanpos;
33502 if (jj_3R_641()) jj_scanpos = xsp;
33503 if (jj_3R_233()) return true;
33504 return false;
33505 }
33506
33507 private boolean jj_3R_243() {
33508 if (jj_scan_token(TYPE)) return true;
33509 if (jj_3R_120()) return true;
33510 Token xsp;
33511 xsp = jj_scanpos;
33512 if (jj_scan_token(152)) {
33513 jj_scanpos = xsp;
33514 if (jj_scan_token(51)) return true;
33515 }
33516 xsp = jj_scanpos;
33517 if (jj_3_44()) {
33518 jj_scanpos = xsp;
33519 if (jj_3R_493()) {
33520 jj_scanpos = xsp;
33521 if (jj_3R_494()) {
33522 jj_scanpos = xsp;
33523 if (jj_3R_495()) {
33524 jj_scanpos = xsp;
33525 if (jj_3R_496()) {
33526 jj_scanpos = xsp;
33527 if (jj_3R_497()) {
33528 jj_scanpos = xsp;
33529 if (jj_3R_498()) return true;
33530 }
33531 }
33532 }
33533 }
33534 }
33535 }
33536 return false;
33537 }
33538
33539 private boolean jj_3R_636() {
33540 if (jj_scan_token(6)) return true;
33541 if (jj_3R_233()) return true;
33542 return false;
33543 }
33544
33545 private boolean jj_3R_635() {
33546 if (jj_scan_token(6)) return true;
33547 Token xsp;
33548 xsp = jj_scanpos;
33549 if (jj_3R_639()) jj_scanpos = xsp;
33550 if (jj_3R_233()) return true;
33551 return false;
33552 }
33553
33554 private boolean jj_3R_242() {
33555 if (jj_scan_token(SUBTYPE)) return true;
33556 if (jj_3R_120()) return true;
33557 if (jj_scan_token(IS)) return true;
33558 if (jj_3R_235()) return true;
33559 Token xsp;
33560 xsp = jj_scanpos;
33561 if (jj_3R_491()) jj_scanpos = xsp;
33562 xsp = jj_scanpos;
33563 if (jj_3R_492()) jj_scanpos = xsp;
33564 return false;
33565 }
33566
33567 private boolean jj_3R_619() {
33568 if (jj_3R_173()) return true;
33569 return false;
33570 }
33571
33572 private boolean jj_3R_152() {
33573 Token xsp;
33574 xsp = jj_scanpos;
33575 if (jj_3R_242()) {
33576 jj_scanpos = xsp;
33577 if (jj_3R_243()) return true;
33578 }
33579 if (jj_scan_token(4)) return true;
33580 return false;
33581 }
33582
33583 private boolean jj_3R_555() {
33584 if (jj_scan_token(LIMIT)) return true;
33585 if (jj_3R_233()) return true;
33586 return false;
33587 }
33588
33589 private boolean jj_3R_596() {
33590 if (jj_scan_token(CC_ELSE)) return true;
33591 Token xsp;
33592 if (jj_3R_619()) return true;
33593 while (true) {
33594 xsp = jj_scanpos;
33595 if (jj_3R_619()) { jj_scanpos = xsp; break; }
33596 }
33597 return false;
33598 }
33599
33600 private boolean jj_3R_595() {
33601 if (jj_scan_token(CC_ELSIF)) return true;
33602 if (jj_3R_343()) return true;
33603 if (jj_scan_token(CC_THEN)) return true;
33604 Token xsp;
33605 if (jj_3R_640()) return true;
33606 while (true) {
33607 xsp = jj_scanpos;
33608 if (jj_3R_640()) { jj_scanpos = xsp; break; }
33609 }
33610 return false;
33611 }
33612
33613 private boolean jj_3R_456() {
33614 if (jj_scan_token(CC_ERROR)) return true;
33615 if (jj_3R_233()) return true;
33616 if (jj_scan_token(CC_END)) return true;
33617 return false;
33618 }
33619
33620 private boolean jj_3R_455() {
33621 if (jj_scan_token(CC_IF)) return true;
33622 if (jj_3R_343()) return true;
33623 if (jj_scan_token(CC_THEN)) return true;
33624 Token xsp;
33625 while (true) {
33626 xsp = jj_scanpos;
33627 if (jj_3R_594()) { jj_scanpos = xsp; break; }
33628 }
33629 while (true) {
33630 xsp = jj_scanpos;
33631 if (jj_3R_595()) { jj_scanpos = xsp; break; }
33632 }
33633 while (true) {
33634 xsp = jj_scanpos;
33635 if (jj_3R_596()) { jj_scanpos = xsp; break; }
33636 }
33637 if (jj_scan_token(CC_END)) return true;
33638 return false;
33639 }
33640
33641 private boolean jj_3R_617() {
33642 Token xsp;
33643 xsp = jj_scanpos;
33644 if (jj_scan_token(137)) {
33645 jj_scanpos = xsp;
33646 if (jj_scan_token(207)) {
33647 jj_scanpos = xsp;
33648 if (jj_scan_token(138)) return true;
33649 }
33650 }
33651 return false;
33652 }
33653
33654 private boolean jj_3R_634() {
33655 if (jj_scan_token(6)) return true;
33656 if (jj_3R_294()) return true;
33657 return false;
33658 }
33659
33660 private boolean jj_3R_420() {
33661 Token xsp;
33662 xsp = jj_scanpos;
33663 if (jj_3R_455()) {
33664 jj_scanpos = xsp;
33665 if (jj_3R_456()) return true;
33666 }
33667 return false;
33668 }
33669
33670 private boolean jj_3R_618() {
33671 if (jj_scan_token(IN)) return true;
33672 Token xsp;
33673 xsp = jj_scanpos;
33674 if (jj_scan_token(207)) jj_scanpos = xsp;
33675 return false;
33676 }
33677
33678 private boolean jj_3R_593() {
33679 Token xsp;
33680 xsp = jj_scanpos;
33681 if (jj_3R_618()) {
33682 jj_scanpos = xsp;
33683 if (jj_scan_token(207)) return true;
33684 }
33685 return false;
33686 }
33687
33688 private boolean jj_3R_553() {
33689 if (jj_scan_token(BULK)) return true;
33690 if (jj_scan_token(COLLECT)) return true;
33691 return false;
33692 }
33693
33694 private boolean jj_3R_554() {
33695 if (jj_scan_token(6)) return true;
33696 if (jj_3R_233()) return true;
33697 return false;
33698 }
33699
33700 private boolean jj_3R_419() {
33701 if (jj_scan_token(PIPE)) return true;
33702 if (jj_scan_token(ROW)) return true;
33703 if (jj_3R_233()) return true;
33704 return false;
33705 }
33706
33707 private boolean jj_3R_592() {
33708 if (jj_scan_token(USING)) return true;
33709 Token xsp;
33710 xsp = jj_scanpos;
33711 if (jj_3R_617()) jj_scanpos = xsp;
33712 if (jj_3R_233()) return true;
33713 while (true) {
33714 xsp = jj_scanpos;
33715 if (jj_3R_638()) { jj_scanpos = xsp; break; }
33716 }
33717 return false;
33718 }
33719
33720 private boolean jj_3R_558() {
33721 Token xsp;
33722 xsp = jj_scanpos;
33723 if (jj_scan_token(237)) {
33724 jj_scanpos = xsp;
33725 if (jj_scan_token(238)) return true;
33726 }
33727 if (jj_scan_token(INTO)) return true;
33728 if (jj_3R_233()) return true;
33729 while (true) {
33730 xsp = jj_scanpos;
33731 if (jj_3R_636()) { jj_scanpos = xsp; break; }
33732 }
33733 return false;
33734 }
33735
33736 private boolean jj_3R_557() {
33737 if (jj_scan_token(USING)) return true;
33738 Token xsp;
33739 xsp = jj_scanpos;
33740 if (jj_3R_593()) jj_scanpos = xsp;
33741 if (jj_3R_233()) return true;
33742 while (true) {
33743 xsp = jj_scanpos;
33744 if (jj_3R_635()) { jj_scanpos = xsp; break; }
33745 }
33746 return false;
33747 }
33748
33749 private boolean jj_3R_556() {
33750 if (jj_scan_token(INTO)) return true;
33751 if (jj_3R_294()) return true;
33752 Token xsp;
33753 while (true) {
33754 xsp = jj_scanpos;
33755 if (jj_3R_634()) { jj_scanpos = xsp; break; }
33756 }
33757 return false;
33758 }
33759
33760 private boolean jj_3R_403() {
33761 if (jj_scan_token(INTERFACE)) return true;
33762 if (jj_scan_token(5)) return true;
33763 return false;
33764 }
33765
33766 private boolean jj_3R_402() {
33767 if (jj_scan_token(EXCEPTION_INIT)) return true;
33768 if (jj_scan_token(5)) return true;
33769 return false;
33770 }
33771
33772 private boolean jj_3R_401() {
33773 if (jj_scan_token(RESTRICT_REFERENCES)) return true;
33774 if (jj_scan_token(5)) return true;
33775 return false;
33776 }
33777
33778 private boolean jj_3R_451() {
33779 if (jj_scan_token(WHEN)) return true;
33780 if (jj_3R_233()) return true;
33781 return false;
33782 }
33783
33784 private boolean jj_3R_418() {
33785 if (jj_scan_token(EXECUTE)) return true;
33786 if (jj_scan_token(IMMEDIATE)) return true;
33787 if (jj_3R_233()) return true;
33788 Token xsp;
33789 xsp = jj_scanpos;
33790 if (jj_3R_556()) jj_scanpos = xsp;
33791 xsp = jj_scanpos;
33792 if (jj_3R_557()) jj_scanpos = xsp;
33793 xsp = jj_scanpos;
33794 if (jj_3R_558()) jj_scanpos = xsp;
33795 if (jj_scan_token(4)) return true;
33796 return false;
33797 }
33798
33799 private boolean jj_3R_454() {
33800 if (jj_scan_token(FOR)) return true;
33801 if (jj_3R_233()) return true;
33802 Token xsp;
33803 xsp = jj_scanpos;
33804 if (jj_3R_592()) jj_scanpos = xsp;
33805 return false;
33806 }
33807
33808 private boolean jj_3R_417() {
33809 if (jj_scan_token(FETCH)) return true;
33810 if (jj_3R_128()) return true;
33811 Token xsp;
33812 xsp = jj_scanpos;
33813 if (jj_3R_553()) jj_scanpos = xsp;
33814 if (jj_scan_token(INTO)) return true;
33815 if (jj_3R_233()) return true;
33816 while (true) {
33817 xsp = jj_scanpos;
33818 if (jj_3R_554()) { jj_scanpos = xsp; break; }
33819 }
33820 xsp = jj_scanpos;
33821 if (jj_3R_555()) jj_scanpos = xsp;
33822 return false;
33823 }
33824
33825 private boolean jj_3R_208() {
33826 if (jj_scan_token(WHEN)) return true;
33827 if (jj_3R_233()) return true;
33828 return false;
33829 }
33830
33831 private boolean jj_3R_453() {
33832 if (jj_3R_233()) return true;
33833 return false;
33834 }
33835
33836 private boolean jj_3R_351() {
33837 if (jj_scan_token(PRAGMA)) return true;
33838 Token xsp;
33839 xsp = jj_scanpos;
33840 if (jj_scan_token(38)) {
33841 jj_scanpos = xsp;
33842 if (jj_scan_token(41)) {
33843 jj_scanpos = xsp;
33844 if (jj_3R_401()) {
33845 jj_scanpos = xsp;
33846 if (jj_3R_402()) {
33847 jj_scanpos = xsp;
33848 if (jj_3R_403()) return true;
33849 }
33850 }
33851 }
33852 }
33853 return false;
33854 }
33855
33856 private boolean jj_3R_416() {
33857 if (jj_scan_token(OPEN)) return true;
33858 Token xsp;
33859 xsp = jj_scanpos;
33860 if (jj_3R_453()) jj_scanpos = xsp;
33861 xsp = jj_scanpos;
33862 if (jj_3R_454()) jj_scanpos = xsp;
33863 return false;
33864 }
33865
33866 private boolean jj_3R_452() {
33867 if (jj_3R_128()) return true;
33868 return false;
33869 }
33870
33871 private boolean jj_3R_415() {
33872 if (jj_scan_token(CLOSE)) return true;
33873 if (jj_3R_128()) return true;
33874 return false;
33875 }
33876
33877 private boolean jj_3R_450() {
33878 if (jj_3R_142()) return true;
33879 return false;
33880 }
33881
33882 private boolean jj_3R_414() {
33883 if (jj_scan_token(RAISE)) return true;
33884 Token xsp;
33885 xsp = jj_scanpos;
33886 if (jj_3R_452()) jj_scanpos = xsp;
33887 return false;
33888 }
33889
33890 private boolean jj_3R_207() {
33891 if (jj_3R_142()) return true;
33892 return false;
33893 }
33894
33895 private boolean jj_3R_147() {
33896 if (jj_3R_124()) return true;
33897 if (jj_3R_235()) return true;
33898 return false;
33899 }
33900
33901 private boolean jj_3R_591() {
33902 if (jj_scan_token(12)) return true;
33903 if (jj_3R_233()) return true;
33904 return false;
33905 }
33906
33907 private boolean jj_3R_413() {
33908 if (jj_scan_token(EXIT)) return true;
33909 Token xsp;
33910 xsp = jj_scanpos;
33911 if (jj_3R_450()) jj_scanpos = xsp;
33912 xsp = jj_scanpos;
33913 if (jj_3R_451()) jj_scanpos = xsp;
33914 return false;
33915 }
33916
33917 private boolean jj_3R_449() {
33918 if (jj_3R_233()) return true;
33919 return false;
33920 }
33921
33922 private boolean jj_3R_132() {
33923 if (jj_scan_token(CONTINUE)) return true;
33924 Token xsp;
33925 xsp = jj_scanpos;
33926 if (jj_3R_207()) jj_scanpos = xsp;
33927 xsp = jj_scanpos;
33928 if (jj_3R_208()) jj_scanpos = xsp;
33929 return false;
33930 }
33931
33932 private boolean jj_3R_551() {
33933 if (jj_scan_token(SAVE)) return true;
33934 if (jj_scan_token(EXCEPTIONS)) return true;
33935 return false;
33936 }
33937
33938 private boolean jj_3R_550() {
33939 if (jj_3R_233()) return true;
33940 Token xsp;
33941 xsp = jj_scanpos;
33942 if (jj_3R_591()) jj_scanpos = xsp;
33943 return false;
33944 }
33945
33946 private boolean jj_3R_633() {
33947 if (jj_3R_173()) return true;
33948 return false;
33949 }
33950
33951 private boolean jj_3R_549() {
33952 Token xsp;
33953 xsp = jj_scanpos;
33954 if (jj_scan_token(140)) {
33955 jj_scanpos = xsp;
33956 if (jj_scan_token(289)) return true;
33957 }
33958 if (jj_scan_token(OF)) return true;
33959 if (jj_3R_233()) return true;
33960 return false;
33961 }
33962
33963 private boolean jj_3R_412() {
33964 if (jj_scan_token(RETURN)) return true;
33965 Token xsp;
33966 xsp = jj_scanpos;
33967 if (jj_3R_449()) jj_scanpos = xsp;
33968 return false;
33969 }
33970
33971 private boolean jj_3R_411() {
33972 if (jj_scan_token(GOTO)) return true;
33973 if (jj_3R_128()) return true;
33974 return false;
33975 }
33976
33977 private boolean jj_3R_408() {
33978 if (jj_scan_token(FORALL)) return true;
33979 if (jj_3R_447()) return true;
33980 if (jj_scan_token(IN)) return true;
33981 Token xsp;
33982 xsp = jj_scanpos;
33983 if (jj_3R_549()) {
33984 jj_scanpos = xsp;
33985 if (jj_3R_550()) return true;
33986 }
33987 xsp = jj_scanpos;
33988 if (jj_3R_551()) jj_scanpos = xsp;
33989 if (jj_3R_404()) return true;
33990 return false;
33991 }
33992
33993 private boolean jj_3R_548() {
33994 if (jj_scan_token(12)) return true;
33995 if (jj_3R_233()) return true;
33996 return false;
33997 }
33998
33999 private boolean jj_3R_545() {
34000 if (jj_3R_173()) return true;
34001 return false;
34002 }
34003
34004 private boolean jj_3R_355() {
34005 if (jj_scan_token(CASCADE)) return true;
34006 return false;
34007 }
34008
34009 private boolean jj_3R_552() {
34010 if (jj_3R_173()) return true;
34011 return false;
34012 }
34013
34014 private boolean jj_3R_447() {
34015 if (jj_3R_124()) return true;
34016 return false;
34017 }
34018
34019 private boolean jj_3R_314() {
34020 Token xsp;
34021 xsp = jj_scanpos;
34022 if (jj_scan_token(151)) {
34023 jj_scanpos = xsp;
34024 if (jj_3R_355()) return true;
34025 }
34026 return false;
34027 }
34028
34029 private boolean jj_3R_149() {
34030 if (jj_3R_238()) return true;
34031 return false;
34032 }
34033
34034 private boolean jj_3_72() {
34035 if (jj_3R_146()) return true;
34036 return false;
34037 }
34038
34039 private boolean jj_3R_148() {
34040 if (jj_scan_token(AUTHID)) return true;
34041 Token xsp;
34042 xsp = jj_scanpos;
34043 if (jj_scan_token(37)) {
34044 jj_scanpos = xsp;
34045 if (jj_scan_token(36)) return true;
34046 }
34047 return false;
34048 }
34049
34050 private boolean jj_3R_446() {
34051 if (jj_3R_124()) return true;
34052 return false;
34053 }
34054
34055 private boolean jj_3R_313() {
34056 Token xsp;
34057 xsp = jj_scanpos;
34058 if (jj_scan_token(183)) jj_scanpos = xsp;
34059 xsp = jj_scanpos;
34060 if (jj_scan_token(119)) {
34061 jj_scanpos = xsp;
34062 if (jj_scan_token(145)) {
34063 jj_scanpos = xsp;
34064 if (jj_scan_token(185)) return true;
34065 }
34066 }
34067 return false;
34068 }
34069
34070 private boolean jj_3_71() {
34071 if (jj_3R_146()) return true;
34072 return false;
34073 }
34074
34075 private boolean jj_3R_547() {
34076 if (jj_3R_485()) return true;
34077 return false;
34078 }
34079
34080 private boolean jj_3R_546() {
34081 if (jj_3R_590()) return true;
34082 return false;
34083 }
34084
34085 private boolean jj_3R_406() {
34086 if (jj_scan_token(IF)) return true;
34087 if (jj_3R_233()) return true;
34088 if (jj_scan_token(THEN)) return true;
34089 Token xsp;
34090 if (jj_3R_545()) return true;
34091 while (true) {
34092 xsp = jj_scanpos;
34093 if (jj_3R_545()) { jj_scanpos = xsp; break; }
34094 }
34095 while (true) {
34096 xsp = jj_scanpos;
34097 if (jj_3R_546()) { jj_scanpos = xsp; break; }
34098 }
34099 xsp = jj_scanpos;
34100 if (jj_3R_547()) jj_scanpos = xsp;
34101 if (jj_scan_token(END)) return true;
34102 if (jj_scan_token(IF)) return true;
34103 return false;
34104 }
34105
34106 private boolean jj_3R_637() {
34107 if (jj_3R_173()) return true;
34108 return false;
34109 }
34110
34111 private boolean jj_3R_410() {
34112 if (jj_scan_token(WHILE)) return true;
34113 if (jj_3R_233()) return true;
34114 if (jj_scan_token(LOOP)) return true;
34115 Token xsp;
34116 if (jj_3R_552()) return true;
34117 while (true) {
34118 xsp = jj_scanpos;
34119 if (jj_3R_552()) { jj_scanpos = xsp; break; }
34120 }
34121 if (jj_scan_token(END)) return true;
34122 if (jj_scan_token(LOOP)) return true;
34123 xsp = jj_scanpos;
34124 if (jj_scan_token(420)) jj_scanpos = xsp;
34125 return false;
34126 }
34127
34128 private boolean jj_3R_131() {
34129 if (jj_scan_token(LOCK)) return true;
34130 if (jj_scan_token(TABLE)) return true;
34131 return false;
34132 }
34133
34134 private boolean jj_3_70() {
34135 Token xsp;
34136 xsp = jj_scanpos;
34137 if (jj_3R_148()) {
34138 jj_scanpos = xsp;
34139 if (jj_3R_149()) return true;
34140 }
34141 return false;
34142 }
34143
34144 private boolean jj_3R_312() {
34145 if (jj_scan_token(REPLACE)) return true;
34146 return false;
34147 }
34148
34149 private boolean jj_3R_407() {
34150 if (jj_scan_token(FOR)) return true;
34151 if (jj_3R_446()) return true;
34152 if (jj_scan_token(IN)) return true;
34153 Token xsp;
34154 xsp = jj_scanpos;
34155 if (jj_scan_token(239)) jj_scanpos = xsp;
34156 if (jj_3R_233()) return true;
34157 xsp = jj_scanpos;
34158 if (jj_3R_548()) jj_scanpos = xsp;
34159 if (jj_scan_token(LOOP)) return true;
34160 if (jj_3R_633()) return true;
34161 while (true) {
34162 xsp = jj_scanpos;
34163 if (jj_3R_633()) { jj_scanpos = xsp; break; }
34164 }
34165 if (jj_scan_token(END)) return true;
34166 if (jj_scan_token(LOOP)) return true;
34167 xsp = jj_scanpos;
34168 if (jj_scan_token(420)) jj_scanpos = xsp;
34169 return false;
34170 }
34171
34172 private boolean jj_3R_615() {
34173 if (jj_3R_173()) return true;
34174 return false;
34175 }
34176
34177 private boolean jj_3R_448() {
34178 if (jj_3R_173()) return true;
34179 return false;
34180 }
34181
34182 private boolean jj_3R_409() {
34183 if (jj_scan_token(LOOP)) return true;
34184 Token xsp;
34185 if (jj_3R_448()) return true;
34186 while (true) {
34187 xsp = jj_scanpos;
34188 if (jj_3R_448()) { jj_scanpos = xsp; break; }
34189 }
34190 if (jj_scan_token(END)) return true;
34191 if (jj_scan_token(LOOP)) return true;
34192 xsp = jj_scanpos;
34193 if (jj_scan_token(420)) jj_scanpos = xsp;
34194 return false;
34195 }
34196
34197 private boolean jj_3R_130() {
34198 if (jj_scan_token(SET)) return true;
34199 if (jj_scan_token(TRANSACTION)) return true;
34200 return false;
34201 }
34202
34203 private boolean jj_3R_616() {
34204 if (jj_3R_173()) return true;
34205 return false;
34206 }
34207
34208 private boolean jj_3R_590() {
34209 if (jj_scan_token(ELSIF)) return true;
34210 if (jj_3R_233()) return true;
34211 if (jj_scan_token(THEN)) return true;
34212 Token xsp;
34213 if (jj_3R_637()) return true;
34214 while (true) {
34215 xsp = jj_scanpos;
34216 if (jj_3R_637()) { jj_scanpos = xsp; break; }
34217 }
34218 return false;
34219 }
34220
34221 private boolean jj_3R_485() {
34222 if (jj_scan_token(ELSE)) return true;
34223 Token xsp;
34224 if (jj_3R_616()) return true;
34225 while (true) {
34226 xsp = jj_scanpos;
34227 if (jj_3R_616()) { jj_scanpos = xsp; break; }
34228 }
34229 return false;
34230 }
34231
34232 private boolean jj_3R_484() {
34233 if (jj_scan_token(WHEN)) return true;
34234 if (jj_3R_233()) return true;
34235 if (jj_scan_token(THEN)) return true;
34236 Token xsp;
34237 if (jj_3R_615()) return true;
34238 while (true) {
34239 xsp = jj_scanpos;
34240 if (jj_3R_615()) { jj_scanpos = xsp; break; }
34241 }
34242 return false;
34243 }
34244
34245 private boolean jj_3R_443() {
34246 if (jj_3R_233()) return true;
34247 return false;
34248 }
34249
34250 private boolean jj_3R_445() {
34251 if (jj_3R_485()) return true;
34252 return false;
34253 }
34254
34255 private boolean jj_3R_444() {
34256 if (jj_3R_484()) return true;
34257 return false;
34258 }
34259
34260 private boolean jj_3R_405() {
34261 if (jj_scan_token(CASE)) return true;
34262 Token xsp;
34263 xsp = jj_scanpos;
34264 if (jj_3R_443()) jj_scanpos = xsp;
34265 while (true) {
34266 xsp = jj_scanpos;
34267 if (jj_3R_444()) { jj_scanpos = xsp; break; }
34268 }
34269 xsp = jj_scanpos;
34270 if (jj_3R_445()) jj_scanpos = xsp;
34271 if (jj_scan_token(END)) return true;
34272 if (jj_scan_token(CASE)) return true;
34273 xsp = jj_scanpos;
34274 if (jj_scan_token(420)) jj_scanpos = xsp;
34275 return false;
34276 }
34277
34278 private boolean jj_3R_356() {
34279 if (jj_3R_190()) return true;
34280 return false;
34281 }
34282
34283 private boolean jj_3R_354() {
34284 if (jj_scan_token(DROP)) return true;
34285 return false;
34286 }
34287
34288 private boolean jj_3R_315() {
34289 Token xsp;
34290 if (jj_3R_356()) return true;
34291 while (true) {
34292 xsp = jj_scanpos;
34293 if (jj_3R_356()) { jj_scanpos = xsp; break; }
34294 }
34295 if (jj_3R_316()) return true;
34296 return false;
34297 }
34298
34299 private boolean jj_3R_264() {
34300 if (jj_3R_316()) return true;
34301 return false;
34302 }
34303
34304 private boolean jj_3R_263() {
34305 if (jj_3R_315()) return true;
34306 return false;
34307 }
34308
34309 private boolean jj_3R_353() {
34310 Token xsp;
34311 xsp = jj_scanpos;
34312 if (jj_scan_token(6)) jj_scanpos = xsp;
34313 xsp = jj_scanpos;
34314 if (jj_scan_token(44)) {
34315 jj_scanpos = xsp;
34316 if (jj_scan_token(170)) return true;
34317 }
34318 return false;
34319 }
34320
34321 private boolean jj_3R_311() {
34322 Token xsp;
34323 xsp = jj_scanpos;
34324 if (jj_3R_353()) {
34325 jj_scanpos = xsp;
34326 if (jj_3R_354()) return true;
34327 }
34328 return false;
34329 }
34330
34331 private boolean jj_3R_173() {
34332 Token xsp;
34333 xsp = jj_scanpos;
34334 if (jj_3R_263()) {
34335 jj_scanpos = xsp;
34336 if (jj_3R_264()) return true;
34337 }
34338 return false;
34339 }
34340
34341 private boolean jj_3R_376() {
34342 if (jj_3R_233()) return true;
34343 if (jj_scan_token(4)) return true;
34344 return false;
34345 }
34346
34347 private boolean jj_3R_375() {
34348 if (jj_3R_421()) return true;
34349 if (jj_scan_token(4)) return true;
34350 return false;
34351 }
34352
34353 private boolean jj_3R_374() {
34354 if (jj_3R_420()) return true;
34355 return false;
34356 }
34357
34358 private boolean jj_3R_373() {
34359 if (jj_3R_419()) return true;
34360 if (jj_scan_token(4)) return true;
34361 return false;
34362 }
34363
34364 private boolean jj_3R_307() {
34365 if (jj_3R_147()) return true;
34366 return false;
34367 }
34368
34369 private boolean jj_3R_442() {
34370 if (jj_scan_token(LOCK)) return true;
34371 if (jj_scan_token(TABLE)) return true;
34372 return false;
34373 }
34374
34375 private boolean jj_3R_372() {
34376 if (jj_3R_418()) return true;
34377 if (jj_scan_token(4)) return true;
34378 return false;
34379 }
34380
34381 private boolean jj_3R_259() {
34382 if (jj_scan_token(ALTER)) return true;
34383 if (jj_scan_token(TYPE)) return true;
34384 if (jj_3R_128()) return true;
34385 Token xsp;
34386 while (true) {
34387 xsp = jj_scanpos;
34388 if (jj_3R_311()) { jj_scanpos = xsp; break; }
34389 }
34390 xsp = jj_scanpos;
34391 if (jj_3R_312()) jj_scanpos = xsp;
34392 while (true) {
34393 xsp = jj_scanpos;
34394 if (jj_3R_313()) { jj_scanpos = xsp; break; }
34395 }
34396 xsp = jj_scanpos;
34397 if (jj_3R_314()) jj_scanpos = xsp;
34398 return false;
34399 }
34400
34401 private boolean jj_3R_371() {
34402 if (jj_3R_271()) return true;
34403 if (jj_scan_token(4)) return true;
34404 return false;
34405 }
34406
34407 private boolean jj_3R_370() {
34408 if (jj_3R_417()) return true;
34409 if (jj_scan_token(4)) return true;
34410 return false;
34411 }
34412
34413 private boolean jj_3_69() {
34414 if (jj_3R_147()) return true;
34415 return false;
34416 }
34417
34418 private boolean jj_3R_369() {
34419 if (jj_3R_416()) return true;
34420 if (jj_scan_token(4)) return true;
34421 return false;
34422 }
34423
34424 private boolean jj_3R_368() {
34425 if (jj_3R_415()) return true;
34426 if (jj_scan_token(4)) return true;
34427 return false;
34428 }
34429
34430 private boolean jj_3R_367() {
34431 if (jj_3R_414()) return true;
34432 if (jj_scan_token(4)) return true;
34433 return false;
34434 }
34435
34436 private boolean jj_3R_366() {
34437 if (jj_3R_413()) return true;
34438 if (jj_scan_token(4)) return true;
34439 return false;
34440 }
34441
34442 private boolean jj_3R_365() {
34443 if (jj_3R_412()) return true;
34444 if (jj_scan_token(4)) return true;
34445 return false;
34446 }
34447
34448 private boolean jj_3R_364() {
34449 if (jj_3R_411()) return true;
34450 if (jj_scan_token(4)) return true;
34451 return false;
34452 }
34453
34454 private boolean jj_3_42() {
34455 Token xsp;
34456 xsp = jj_scanpos;
34457 if (jj_3R_129()) {
34458 jj_scanpos = xsp;
34459 if (jj_scan_token(297)) {
34460 jj_scanpos = xsp;
34461 if (jj_scan_token(144)) {
34462 jj_scanpos = xsp;
34463 if (jj_scan_token(93)) {
34464 jj_scanpos = xsp;
34465 if (jj_scan_token(76)) {
34466 jj_scanpos = xsp;
34467 if (jj_scan_token(241)) {
34468 jj_scanpos = xsp;
34469 if (jj_scan_token(248)) {
34470 jj_scanpos = xsp;
34471 if (jj_scan_token(111)) {
34472 jj_scanpos = xsp;
34473 if (jj_3R_130()) {
34474 jj_scanpos = xsp;
34475 if (jj_3R_131()) {
34476 jj_scanpos = xsp;
34477 if (jj_scan_token(165)) {
34478 jj_scanpos = xsp;
34479 if (jj_scan_token(318)) return true;
34480 }
34481 }
34482 }
34483 }
34484 }
34485 }
34486 }
34487 }
34488 }
34489 }
34490 }
34491 return false;
34492 }
34493
34494 private boolean jj_3R_129() {
34495 Token xsp;
34496 xsp = jj_scanpos;
34497 if (jj_scan_token(5)) jj_scanpos = xsp;
34498 if (jj_scan_token(SELECT)) return true;
34499 return false;
34500 }
34501
34502 private boolean jj_3R_363() {
34503 if (jj_3R_410()) return true;
34504 if (jj_scan_token(4)) return true;
34505 return false;
34506 }
34507
34508 private boolean jj_3R_362() {
34509 if (jj_3R_409()) return true;
34510 if (jj_scan_token(4)) return true;
34511 return false;
34512 }
34513
34514 private boolean jj_3R_260() {
34515 if (jj_3R_259()) return true;
34516 return false;
34517 }
34518
34519 private boolean jj_3R_361() {
34520 if (jj_3R_408()) return true;
34521 if (jj_scan_token(4)) return true;
34522 return false;
34523 }
34524
34525 private boolean jj_3R_360() {
34526 if (jj_3R_407()) return true;
34527 if (jj_scan_token(4)) return true;
34528 return false;
34529 }
34530
34531 private boolean jj_3R_359() {
34532 if (jj_3R_406()) return true;
34533 if (jj_scan_token(4)) return true;
34534 return false;
34535 }
34536
34537 private boolean jj_3R_167() {
34538 Token xsp;
34539 xsp = jj_scanpos;
34540 if (jj_scan_token(4)) {
34541 jj_scanpos = xsp;
34542 if (jj_scan_token(1)) return true;
34543 }
34544 while (true) {
34545 xsp = jj_scanpos;
34546 if (jj_3R_260()) { jj_scanpos = xsp; break; }
34547 }
34548 return false;
34549 }
34550
34551 private boolean jj_3R_358() {
34552 if (jj_3R_405()) return true;
34553 if (jj_scan_token(4)) return true;
34554 return false;
34555 }
34556
34557 private boolean jj_3_43() {
34558 if (jj_3R_132()) return true;
34559 if (jj_scan_token(4)) return true;
34560 return false;
34561 }
34562
34563 private boolean jj_3R_166() {
34564 if (jj_3R_259()) return true;
34565 return false;
34566 }
34567
34568 private boolean jj_3R_309() {
34569 if (jj_3R_146()) return true;
34570 return false;
34571 }
34572
34573 private boolean jj_3R_310() {
34574 if (jj_3R_351()) return true;
34575 return false;
34576 }
34577
34578 private boolean jj_3R_357() {
34579 if (jj_3R_404()) return true;
34580 Token xsp;
34581 xsp = jj_scanpos;
34582 if (jj_scan_token(4)) jj_scanpos = xsp;
34583 return false;
34584 }
34585
34586 private boolean jj_3R_441() {
34587 if (jj_scan_token(SET)) return true;
34588 if (jj_scan_token(TRANSACTION)) return true;
34589 return false;
34590 }
34591
34592 private boolean jj_3R_316() {
34593 Token xsp;
34594 xsp = jj_scanpos;
34595 if (jj_3R_357()) {
34596 jj_scanpos = xsp;
34597 if (jj_3_43()) {
34598 jj_scanpos = xsp;
34599 if (jj_3R_358()) {
34600 jj_scanpos = xsp;
34601 if (jj_3R_359()) {
34602 jj_scanpos = xsp;
34603 if (jj_3R_360()) {
34604 jj_scanpos = xsp;
34605 if (jj_3R_361()) {
34606 jj_scanpos = xsp;
34607 if (jj_3R_362()) {
34608 jj_scanpos = xsp;
34609 if (jj_3R_363()) {
34610 jj_scanpos = xsp;
34611 if (jj_3R_364()) {
34612 jj_scanpos = xsp;
34613 if (jj_3R_365()) {
34614 jj_scanpos = xsp;
34615 if (jj_3R_366()) {
34616 jj_scanpos = xsp;
34617 if (jj_3R_367()) {
34618 jj_scanpos = xsp;
34619 if (jj_3R_368()) {
34620 jj_scanpos = xsp;
34621 if (jj_3R_369()) {
34622 jj_scanpos = xsp;
34623 if (jj_3R_370()) {
34624 jj_scanpos = xsp;
34625 if (jj_3R_371()) {
34626 jj_scanpos = xsp;
34627 if (jj_3R_372()) {
34628 jj_scanpos = xsp;
34629 if (jj_3R_373()) {
34630 jj_scanpos = xsp;
34631 if (jj_3R_374()) {
34632 jj_scanpos = xsp;
34633 if (jj_3R_375()) {
34634 jj_scanpos = xsp;
34635 if (jj_3R_376()) return true;
34636 }
34637 }
34638 }
34639 }
34640 }
34641 }
34642 }
34643 }
34644 }
34645 }
34646 }
34647 }
34648 }
34649 }
34650 }
34651 }
34652 }
34653 }
34654 }
34655 }
34656 return false;
34657 }
34658
34659 private boolean jj_3R_165() {
34660 Token xsp;
34661 xsp = jj_scanpos;
34662 if (jj_scan_token(183)) jj_scanpos = xsp;
34663 xsp = jj_scanpos;
34664 if (jj_scan_token(119)) {
34665 jj_scanpos = xsp;
34666 if (jj_scan_token(145)) {
34667 jj_scanpos = xsp;
34668 if (jj_scan_token(185)) return true;
34669 }
34670 }
34671 return false;
34672 }
34673
34674 private boolean jj_3R_258() {
34675 if (jj_scan_token(6)) return true;
34676 Token xsp;
34677 xsp = jj_scanpos;
34678 if (jj_3R_309()) {
34679 jj_scanpos = xsp;
34680 if (jj_3_69()) {
34681 jj_scanpos = xsp;
34682 if (jj_3R_310()) return true;
34683 }
34684 }
34685 return false;
34686 }
34687
34688 private boolean jj_3R_308() {
34689 if (jj_3R_351()) return true;
34690 return false;
34691 }
34692
34693 private boolean jj_3_68() {
34694 if (jj_3R_146()) return true;
34695 return false;
34696 }
34697
34698 private boolean jj_3R_257() {
34699 Token xsp;
34700 xsp = jj_scanpos;
34701 if (jj_3_68()) {
34702 jj_scanpos = xsp;
34703 if (jj_3R_307()) {
34704 jj_scanpos = xsp;
34705 if (jj_3R_308()) return true;
34706 }
34707 }
34708 return false;
34709 }
34710
34711 private boolean jj_3R_164() {
34712 if (jj_scan_token(5)) return true;
34713 Token xsp;
34714 while (true) {
34715 xsp = jj_scanpos;
34716 if (jj_3R_257()) { jj_scanpos = xsp; break; }
34717 }
34718 while (true) {
34719 xsp = jj_scanpos;
34720 if (jj_3R_258()) { jj_scanpos = xsp; break; }
34721 }
34722 if (jj_scan_token(7)) return true;
34723 return false;
34724 }
34725
34726 private boolean jj_3R_603() {
34727 if (jj_3R_124()) return true;
34728 return false;
34729 }
34730
34731 private boolean jj_3R_163() {
34732 if (jj_3R_248()) return true;
34733 return false;
34734 }
34735
34736 private boolean jj_3_66() {
34737 Token xsp;
34738 xsp = jj_scanpos;
34739 if (jj_scan_token(152)) {
34740 jj_scanpos = xsp;
34741 if (jj_scan_token(51)) return true;
34742 }
34743 if (jj_3R_145()) return true;
34744 if (jj_scan_token(OF)) return true;
34745 if (jj_3R_235()) return true;
34746 return false;
34747 }
34748
34749 private boolean jj_3R_144() {
34750 if (jj_3R_238()) return true;
34751 return false;
34752 }
34753
34754 private boolean jj_3R_248() {
34755 if (jj_scan_token(WRAPPED)) return true;
34756 return false;
34757 }
34758
34759 private boolean jj_3_65() {
34760 Token xsp;
34761 xsp = jj_scanpos;
34762 if (jj_scan_token(152)) {
34763 jj_scanpos = xsp;
34764 if (jj_scan_token(51)) return true;
34765 }
34766 if (jj_scan_token(OPAQUE)) return true;
34767 if (jj_scan_token(VARYING)) return true;
34768 if (jj_scan_token(24)) return true;
34769 return false;
34770 }
34771
34772 private boolean jj_3_67() {
34773 if (jj_scan_token(EXTERNAL)) return true;
34774 if (jj_scan_token(IDENTIFIER)) return true;
34775 if (jj_scan_token(IDENTIFIER)) return true;
34776 if (jj_scan_token(LANGUAGE)) return true;
34777 if (jj_scan_token(JAVA)) return true;
34778 if (jj_scan_token(USING)) return true;
34779 if (jj_scan_token(IDENTIFIER)) return true;
34780 return false;
34781 }
34782
34783 private boolean jj_3_64() {
34784 Token xsp;
34785 xsp = jj_scanpos;
34786 if (jj_scan_token(152)) {
34787 jj_scanpos = xsp;
34788 if (jj_scan_token(51)) return true;
34789 }
34790 if (jj_scan_token(OBJECT)) return true;
34791 return false;
34792 }
34793
34794 private boolean jj_3R_143() {
34795 if (jj_scan_token(AUTHID)) return true;
34796 Token xsp;
34797 xsp = jj_scanpos;
34798 if (jj_scan_token(37)) {
34799 jj_scanpos = xsp;
34800 if (jj_scan_token(36)) return true;
34801 }
34802 return false;
34803 }
34804
34805 private boolean jj_3R_256() {
34806 if (jj_scan_token(UNDER)) return true;
34807 if (jj_3R_154()) return true;
34808 return false;
34809 }
34810
34811 private boolean jj_3R_162() {
34812 Token xsp;
34813 xsp = jj_scanpos;
34814 if (jj_3R_256()) {
34815 jj_scanpos = xsp;
34816 if (jj_3_64()) {
34817 jj_scanpos = xsp;
34818 if (jj_3_65()) {
34819 jj_scanpos = xsp;
34820 if (jj_3_66()) return true;
34821 }
34822 }
34823 }
34824 return false;
34825 }
34826
34827 private boolean jj_3R_255() {
34828 Token xsp;
34829 xsp = jj_scanpos;
34830 if (jj_scan_token(100)) {
34831 jj_scanpos = xsp;
34832 if (jj_scan_token(182)) return true;
34833 }
34834 return false;
34835 }
34836
34837 private boolean jj_3R_602() {
34838 if (jj_3R_350()) return true;
34839 return false;
34840 }
34841
34842 private boolean jj_3_63() {
34843 Token xsp;
34844 xsp = jj_scanpos;
34845 if (jj_3R_143()) {
34846 jj_scanpos = xsp;
34847 if (jj_3R_144()) return true;
34848 }
34849 return false;
34850 }
34851
34852 private boolean jj_3_62() {
34853 if (jj_scan_token(OID)) return true;
34854 if (jj_scan_token(STRING_LITERAL)) return true;
34855 return false;
34856 }
34857
34858 private boolean jj_3R_254() {
34859 if (jj_scan_token(OR)) return true;
34860 if (jj_scan_token(REPLACE)) return true;
34861 return false;
34862 }
34863
34864 private boolean jj_3R_601() {
34865 if (jj_3R_173()) return true;
34866 return false;
34867 }
34868
34869 private boolean jj_3R_161() {
34870 if (jj_scan_token(CREATE)) return true;
34871 Token xsp;
34872 xsp = jj_scanpos;
34873 if (jj_3R_254()) jj_scanpos = xsp;
34874 xsp = jj_scanpos;
34875 if (jj_3R_255()) jj_scanpos = xsp;
34876 return false;
34877 }
34878
34879 private boolean jj_3R_105() {
34880 Token xsp;
34881 xsp = jj_scanpos;
34882 if (jj_3R_161()) jj_scanpos = xsp;
34883 if (jj_scan_token(TYPE)) return true;
34884 if (jj_3R_154()) return true;
34885 xsp = jj_scanpos;
34886 if (jj_scan_token(123)) jj_scanpos = xsp;
34887 xsp = jj_scanpos;
34888 if (jj_3_62()) jj_scanpos = xsp;
34889 while (true) {
34890 xsp = jj_scanpos;
34891 if (jj_3_63()) { jj_scanpos = xsp; break; }
34892 }
34893 xsp = jj_scanpos;
34894 if (jj_3R_162()) jj_scanpos = xsp;
34895 xsp = jj_scanpos;
34896 if (jj_3_67()) jj_scanpos = xsp;
34897 xsp = jj_scanpos;
34898 if (jj_3R_163()) jj_scanpos = xsp;
34899 xsp = jj_scanpos;
34900 if (jj_3R_164()) jj_scanpos = xsp;
34901 while (true) {
34902 xsp = jj_scanpos;
34903 if (jj_3R_165()) { jj_scanpos = xsp; break; }
34904 }
34905 while (true) {
34906 xsp = jj_scanpos;
34907 if (jj_3R_166()) { jj_scanpos = xsp; break; }
34908 }
34909 xsp = jj_scanpos;
34910 if (jj_3R_167()) jj_scanpos = xsp;
34911 return false;
34912 }
34913
34914 private boolean jj_3R_404() {
34915 Token xsp;
34916 xsp = jj_scanpos;
34917 if (jj_scan_token(250)) {
34918 jj_scanpos = xsp;
34919 if (jj_scan_token(297)) {
34920 jj_scanpos = xsp;
34921 if (jj_scan_token(144)) {
34922 jj_scanpos = xsp;
34923 if (jj_scan_token(93)) {
34924 jj_scanpos = xsp;
34925 if (jj_scan_token(76)) {
34926 jj_scanpos = xsp;
34927 if (jj_scan_token(241)) {
34928 jj_scanpos = xsp;
34929 if (jj_scan_token(248)) {
34930 jj_scanpos = xsp;
34931 if (jj_scan_token(111)) {
34932 jj_scanpos = xsp;
34933 if (jj_3R_441()) {
34934 jj_scanpos = xsp;
34935 if (jj_3R_442()) {
34936 jj_scanpos = xsp;
34937 if (jj_scan_token(165)) {
34938 jj_scanpos = xsp;
34939 if (jj_scan_token(318)) return true;
34940 }
34941 }
34942 }
34943 }
34944 }
34945 }
34946 }
34947 }
34948 }
34949 }
34950 }
34951 if (jj_3R_179()) return true;
34952 return false;
34953 }
34954
34955 private boolean jj_3R_567() {
34956 if (jj_3R_191()) return true;
34957 if (jj_scan_token(BEGIN)) return true;
34958 Token xsp;
34959 while (true) {
34960 xsp = jj_scanpos;
34961 if (jj_3R_601()) { jj_scanpos = xsp; break; }
34962 }
34963 xsp = jj_scanpos;
34964 if (jj_3R_602()) jj_scanpos = xsp;
34965 if (jj_scan_token(END)) return true;
34966 xsp = jj_scanpos;
34967 if (jj_3R_603()) jj_scanpos = xsp;
34968 if (jj_scan_token(4)) return true;
34969 return false;
34970 }
34971
34972 private boolean jj_3R_566() {
34973 if (jj_3R_123()) return true;
34974 Token xsp;
34975 xsp = jj_scanpos;
34976 if (jj_scan_token(4)) jj_scanpos = xsp;
34977 return false;
34978 }
34979
34980 private boolean jj_3R_490() {
34981 return false;
34982 }
34983
34984 private boolean jj_3R_530() {
34985 Token xsp;
34986 xsp = jj_scanpos;
34987 if (jj_scan_token(152)) {
34988 jj_scanpos = xsp;
34989 if (jj_scan_token(51)) return true;
34990 }
34991 xsp = jj_scanpos;
34992 if (jj_3R_566()) {
34993 jj_scanpos = xsp;
34994 if (jj_3R_567()) return true;
34995 }
34996 return false;
34997 }
34998
34999 private boolean jj_3_60() {
35000 if (jj_3R_124()) return true;
35001 if (jj_scan_token(3)) return true;
35002 return false;
35003 }
35004
35005 private boolean jj_3R_241() {
35006 Token xsp;
35007 xsp = jj_scanpos;
35008 if (jj_scan_token(162)) {
35009 jj_scanpos = xsp;
35010 if (jj_scan_token(204)) return true;
35011 }
35012 return false;
35013 }
35014
35015 private boolean jj_3R_240() {
35016 Token xsp;
35017 xsp = jj_scanpos;
35018 if (jj_scan_token(183)) jj_scanpos = xsp;
35019 xsp = jj_scanpos;
35020 if (jj_scan_token(208)) {
35021 jj_scanpos = xsp;
35022 if (jj_scan_token(145)) {
35023 jj_scanpos = xsp;
35024 if (jj_scan_token(119)) return true;
35025 }
35026 }
35027 return false;
35028 }
35029
35030 private boolean jj_3R_187() {
35031 return false;
35032 }
35033
35034 private boolean jj_3_61() {
35035 if (jj_3R_124()) return true;
35036 if (jj_scan_token(3)) return true;
35037 if (jj_3R_124()) return true;
35038 if (jj_scan_token(3)) return true;
35039 if (jj_3R_124()) return true;
35040 return false;
35041 }
35042
35043 private boolean jj_3R_146() {
35044 Token xsp;
35045 while (true) {
35046 xsp = jj_scanpos;
35047 if (jj_3R_240()) { jj_scanpos = xsp; break; }
35048 }
35049 xsp = jj_scanpos;
35050 if (jj_3R_241()) jj_scanpos = xsp;
35051 xsp = jj_scanpos;
35052 if (jj_scan_token(80)) {
35053 jj_scanpos = xsp;
35054 if (jj_scan_token(164)) {
35055 jj_scanpos = xsp;
35056 if (jj_scan_token(262)) return true;
35057 }
35058 }
35059 if (jj_3R_193()) return true;
35060 xsp = jj_scanpos;
35061 if (jj_scan_token(95)) jj_scanpos = xsp;
35062 xsp = jj_scanpos;
35063 if (jj_scan_token(210)) jj_scanpos = xsp;
35064 xsp = jj_scanpos;
35065 if (jj_scan_token(214)) jj_scanpos = xsp;
35066 xsp = jj_scanpos;
35067 if (jj_scan_token(236)) jj_scanpos = xsp;
35068 xsp = jj_scanpos;
35069 if (jj_3R_530()) jj_scanpos = xsp;
35070 return false;
35071 }
35072
35073 private boolean jj_3R_189() {
35074 return false;
35075 }
35076
35077 private boolean jj_3R_261() {
35078 if (jj_3R_124()) return true;
35079 return false;
35080 }
35081
35082 private boolean jj_3R_458() {
35083 if (jj_3R_173()) return true;
35084 return false;
35085 }
35086
35087 private boolean jj_3R_184() {
35088 if (jj_3R_142()) return true;
35089 if (jj_scan_token(IDENTIFIED)) return true;
35090 return false;
35091 }
35092
35093 private boolean jj_3R_183() {
35094 if (jj_scan_token(CONNECT)) return true;
35095 if (jj_scan_token(TO)) return true;
35096 return false;
35097 }
35098
35099 private boolean jj_3R_112() {
35100 if (jj_scan_token(CREATE)) return true;
35101 Token xsp;
35102 xsp = jj_scanpos;
35103 if (jj_scan_token(410)) jj_scanpos = xsp;
35104 xsp = jj_scanpos;
35105 if (jj_scan_token(224)) jj_scanpos = xsp;
35106 if (jj_scan_token(DATABASE)) return true;
35107 if (jj_scan_token(LINK)) return true;
35108 if (jj_3R_154()) return true;
35109 xsp = jj_scanpos;
35110 if (jj_3R_183()) {
35111 jj_scanpos = xsp;
35112 if (jj_3R_184()) return true;
35113 }
35114 return false;
35115 }
35116
35117 private boolean jj_3R_563() {
35118 return false;
35119 }
35120
35121 private boolean jj_3R_181() {
35122 if (jj_scan_token(OR)) return true;
35123 if (jj_scan_token(REPLACE)) return true;
35124 return false;
35125 }
35126
35127 private boolean jj_3R_457() {
35128 if (jj_scan_token(OR)) return true;
35129 if (jj_3R_128()) return true;
35130 return false;
35131 }
35132
35133 private boolean jj_3R_111() {
35134 if (jj_scan_token(CREATE)) return true;
35135 Token xsp;
35136 xsp = jj_scanpos;
35137 if (jj_3R_181()) jj_scanpos = xsp;
35138 if (jj_scan_token(DIRECTORY)) return true;
35139 if (jj_3R_154()) return true;
35140 if (jj_scan_token(AS)) return true;
35141 if (jj_3R_182()) return true;
35142 xsp = jj_scanpos;
35143 if (jj_scan_token(4)) {
35144 jj_scanpos = xsp;
35145 if (jj_scan_token(1)) return true;
35146 }
35147 return false;
35148 }
35149
35150 private boolean jj_3R_180() {
35151 if (jj_scan_token(OR)) return true;
35152 if (jj_scan_token(REPLACE)) return true;
35153 return false;
35154 }
35155
35156 private boolean jj_3R_459() {
35157 if (jj_3R_173()) return true;
35158 return false;
35159 }
35160
35161 private boolean jj_3R_262() {
35162 if (jj_scan_token(6)) return true;
35163 return false;
35164 }
35165
35166 private boolean jj_3R_110() {
35167 if (jj_scan_token(CREATE)) return true;
35168 Token xsp;
35169 xsp = jj_scanpos;
35170 if (jj_3R_180()) jj_scanpos = xsp;
35171 xsp = jj_scanpos;
35172 if (jj_scan_token(224)) jj_scanpos = xsp;
35173 if (jj_scan_token(SYNONYM)) return true;
35174 if (jj_3R_154()) return true;
35175 if (jj_scan_token(FOR)) return true;
35176 if (jj_3R_154()) return true;
35177 xsp = jj_scanpos;
35178 if (jj_scan_token(4)) {
35179 jj_scanpos = xsp;
35180 if (jj_scan_token(1)) return true;
35181 }
35182 return false;
35183 }
35184
35185 private boolean jj_3R_179() {
35186 return false;
35187 }
35188
35189 private boolean jj_3R_170() {
35190 if (jj_scan_token(OR)) return true;
35191 if (jj_scan_token(REPLACE)) return true;
35192 return false;
35193 }
35194
35195 private boolean jj_3R_172() {
35196 if (jj_scan_token(5)) return true;
35197 if (jj_3R_261()) return true;
35198 Token xsp;
35199 while (true) {
35200 xsp = jj_scanpos;
35201 if (jj_3R_262()) { jj_scanpos = xsp; break; }
35202 }
35203 if (jj_scan_token(7)) return true;
35204 return false;
35205 }
35206
35207 private boolean jj_3R_400() {
35208 if (jj_scan_token(WHEN)) return true;
35209 if (jj_scan_token(OTHERS)) return true;
35210 if (jj_scan_token(THEN)) return true;
35211 Token xsp;
35212 if (jj_3R_459()) return true;
35213 while (true) {
35214 xsp = jj_scanpos;
35215 if (jj_3R_459()) { jj_scanpos = xsp; break; }
35216 }
35217 return false;
35218 }
35219
35220 private boolean jj_3_41() {
35221 if (jj_scan_token(WHEN)) return true;
35222 if (jj_3R_128()) return true;
35223 Token xsp;
35224 while (true) {
35225 xsp = jj_scanpos;
35226 if (jj_3R_457()) { jj_scanpos = xsp; break; }
35227 }
35228 if (jj_scan_token(THEN)) return true;
35229 if (jj_3R_458()) return true;
35230 while (true) {
35231 xsp = jj_scanpos;
35232 if (jj_3R_458()) { jj_scanpos = xsp; break; }
35233 }
35234 return false;
35235 }
35236
35237 private boolean jj_3R_171() {
35238 Token xsp;
35239 xsp = jj_scanpos;
35240 if (jj_scan_token(179)) jj_scanpos = xsp;
35241 if (jj_scan_token(FORCE)) return true;
35242 return false;
35243 }
35244
35245 private boolean jj_3R_107() {
35246 if (jj_scan_token(CREATE)) return true;
35247 Token xsp;
35248 xsp = jj_scanpos;
35249 if (jj_3R_170()) jj_scanpos = xsp;
35250 xsp = jj_scanpos;
35251 if (jj_3R_171()) jj_scanpos = xsp;
35252 if (jj_scan_token(VIEW)) return true;
35253 if (jj_3R_154()) return true;
35254 xsp = jj_scanpos;
35255 if (jj_3R_172()) jj_scanpos = xsp;
35256 if (jj_scan_token(AS)) return true;
35257 if (jj_3R_173()) return true;
35258 xsp = jj_scanpos;
35259 if (jj_scan_token(4)) {
35260 jj_scanpos = xsp;
35261 if (jj_scan_token(1)) return true;
35262 }
35263 return false;
35264 }
35265
35266 private boolean jj_3R_169() {
35267 if (jj_3R_124()) return true;
35268 if (jj_3R_235()) return true;
35269 return false;
35270 }
35271
35272 private boolean jj_3R_350() {
35273 if (jj_scan_token(EXCEPTION)) return true;
35274 Token xsp;
35275 while (true) {
35276 xsp = jj_scanpos;
35277 if (jj_3_41()) { jj_scanpos = xsp; break; }
35278 }
35279 xsp = jj_scanpos;
35280 if (jj_3R_400()) jj_scanpos = xsp;
35281 return false;
35282 }
35283
35284 private boolean jj_3R_628() {
35285 if (jj_scan_token(6)) return true;
35286 if (jj_3R_124()) return true;
35287 return false;
35288 }
35289
35290 private boolean jj_3R_627() {
35291 if (jj_scan_token(6)) return true;
35292 if (jj_3R_124()) return true;
35293 return false;
35294 }
35295
35296 private boolean jj_3R_168() {
35297 if (jj_scan_token(GLOBAL)) return true;
35298 if (jj_scan_token(TEMPORARY)) return true;
35299 return false;
35300 }
35301
35302 private boolean jj_3_59() {
35303 if (jj_scan_token(ON)) return true;
35304 if (jj_scan_token(COMMIT)) return true;
35305 return false;
35306 }
35307
35308 private boolean jj_3_40() {
35309 if (jj_scan_token(5)) return true;
35310 if (jj_3R_127()) return true;
35311 if (jj_scan_token(7)) return true;
35312 return false;
35313 }
35314
35315 private boolean jj_3R_106() {
35316 if (jj_scan_token(CREATE)) return true;
35317 Token xsp;
35318 xsp = jj_scanpos;
35319 if (jj_3R_168()) jj_scanpos = xsp;
35320 if (jj_scan_token(TABLE)) return true;
35321 if (jj_3R_154()) return true;
35322 if (jj_scan_token(5)) return true;
35323 if (jj_3R_169()) return true;
35324 return false;
35325 }
35326
35327 private boolean jj_3R_620() {
35328 Token xsp;
35329 xsp = jj_scanpos;
35330 if (jj_scan_token(125)) {
35331 jj_scanpos = xsp;
35332 if (jj_scan_token(223)) {
35333 jj_scanpos = xsp;
35334 if (jj_scan_token(209)) {
35335 jj_scanpos = xsp;
35336 if (jj_scan_token(282)) {
35337 jj_scanpos = xsp;
35338 if (jj_scan_token(284)) return true;
35339 }
35340 }
35341 }
35342 }
35343 return false;
35344 }
35345
35346 private boolean jj_3R_480() {
35347 if (jj_scan_token(TO)) return true;
35348 Token xsp;
35349 xsp = jj_scanpos;
35350 if (jj_scan_token(316)) {
35351 jj_scanpos = xsp;
35352 if (jj_scan_token(173)) {
35353 jj_scanpos = xsp;
35354 if (jj_scan_token(89)) {
35355 jj_scanpos = xsp;
35356 if (jj_scan_token(133)) {
35357 jj_scanpos = xsp;
35358 if (jj_scan_token(168)) {
35359 jj_scanpos = xsp;
35360 if (jj_scan_token(249)) return true;
35361 }
35362 }
35363 }
35364 }
35365 }
35366 xsp = jj_scanpos;
35367 if (jj_3_40()) jj_scanpos = xsp;
35368 return false;
35369 }
35370
35371 private boolean jj_3R_506() {
35372 if (jj_scan_token(LOCAL)) return true;
35373 return false;
35374 }
35375
35376 private boolean jj_3R_348() {
35377 Token xsp;
35378 xsp = jj_scanpos;
35379 if (jj_scan_token(125)) {
35380 jj_scanpos = xsp;
35381 if (jj_scan_token(223)) {
35382 jj_scanpos = xsp;
35383 if (jj_scan_token(209)) {
35384 jj_scanpos = xsp;
35385 if (jj_scan_token(282)) {
35386 jj_scanpos = xsp;
35387 if (jj_scan_token(284)) return true;
35388 }
35389 }
35390 }
35391 }
35392 return false;
35393 }
35394
35395 private boolean jj_3R_349() {
35396 if (jj_scan_token(6)) return true;
35397 Token xsp;
35398 xsp = jj_scanpos;
35399 if (jj_3R_620()) jj_scanpos = xsp;
35400 if (jj_3R_128()) return true;
35401 return false;
35402 }
35403
35404 private boolean jj_3R_479() {
35405 if (jj_scan_token(WITH)) return true;
35406 Token xsp;
35407 xsp = jj_scanpos;
35408 if (jj_3R_506()) jj_scanpos = xsp;
35409 if (jj_scan_token(TIME)) return true;
35410 if (jj_scan_token(ZONE)) return true;
35411 return false;
35412 }
35413
35414 private boolean jj_3R_434() {
35415 Token xsp;
35416 xsp = jj_scanpos;
35417 if (jj_3R_479()) {
35418 jj_scanpos = xsp;
35419 if (jj_3R_480()) return true;
35420 }
35421 return false;
35422 }
35423
35424 private boolean jj_3R_489() {
35425 if (jj_scan_token(6)) return true;
35426 if (jj_3R_127()) return true;
35427 return false;
35428 }
35429
35430 private boolean jj_3_39() {
35431 if (jj_scan_token(5)) return true;
35432 if (jj_3R_127()) return true;
35433 if (jj_scan_token(7)) return true;
35434 return false;
35435 }
35436
35437 private boolean jj_3R_488() {
35438 Token xsp;
35439 xsp = jj_scanpos;
35440 if (jj_scan_token(16)) {
35441 jj_scanpos = xsp;
35442 if (jj_scan_token(17)) return true;
35443 }
35444 return false;
35445 }
35446
35447 private boolean jj_3R_238() {
35448 if (jj_scan_token(ACCESSIBLE)) return true;
35449 if (jj_scan_token(BY)) return true;
35450 if (jj_scan_token(5)) return true;
35451 Token xsp;
35452 xsp = jj_scanpos;
35453 if (jj_3R_348()) jj_scanpos = xsp;
35454 if (jj_3R_128()) return true;
35455 while (true) {
35456 xsp = jj_scanpos;
35457 if (jj_3R_349()) { jj_scanpos = xsp; break; }
35458 }
35459 if (jj_scan_token(7)) return true;
35460 return false;
35461 }
35462
35463 private boolean jj_3R_621() {
35464 Token xsp;
35465 xsp = jj_scanpos;
35466 if (jj_scan_token(130)) {
35467 jj_scanpos = xsp;
35468 if (jj_scan_token(226)) return true;
35469 }
35470 if (jj_scan_token(5)) return true;
35471 if (jj_3R_124()) return true;
35472 while (true) {
35473 xsp = jj_scanpos;
35474 if (jj_3R_627()) { jj_scanpos = xsp; break; }
35475 }
35476 if (jj_scan_token(7)) return true;
35477 return false;
35478 }
35479
35480 private boolean jj_3R_622() {
35481 Token xsp;
35482 xsp = jj_scanpos;
35483 if (jj_scan_token(204)) {
35484 jj_scanpos = xsp;
35485 if (jj_scan_token(71)) return true;
35486 }
35487 if (jj_scan_token(BY)) return true;
35488 if (jj_scan_token(5)) return true;
35489 if (jj_3R_124()) return true;
35490 while (true) {
35491 xsp = jj_scanpos;
35492 if (jj_3R_628()) { jj_scanpos = xsp; break; }
35493 }
35494 if (jj_scan_token(7)) return true;
35495 return false;
35496 }
35497
35498 private boolean jj_3R_433() {
35499 Token xsp;
35500 xsp = jj_scanpos;
35501 if (jj_scan_token(316)) {
35502 jj_scanpos = xsp;
35503 if (jj_scan_token(173)) {
35504 jj_scanpos = xsp;
35505 if (jj_scan_token(89)) {
35506 jj_scanpos = xsp;
35507 if (jj_scan_token(133)) {
35508 jj_scanpos = xsp;
35509 if (jj_scan_token(168)) {
35510 jj_scanpos = xsp;
35511 if (jj_scan_token(249)) return true;
35512 }
35513 }
35514 }
35515 }
35516 }
35517 return false;
35518 }
35519
35520 private boolean jj_3R_432() {
35521 if (jj_3R_182()) return true;
35522 return false;
35523 }
35524
35525 private boolean jj_3R_431() {
35526 if (jj_scan_token(CHARACTER_LITERAL)) return true;
35527 return false;
35528 }
35529
35530 private boolean jj_3R_428() {
35531 if (jj_scan_token(5)) return true;
35532 if (jj_scan_token(PARTITION)) return true;
35533 if (jj_3R_124()) return true;
35534 if (jj_scan_token(BY)) return true;
35535 Token xsp;
35536 xsp = jj_scanpos;
35537 if (jj_scan_token(49)) {
35538 jj_scanpos = xsp;
35539 if (jj_3R_621()) return true;
35540 }
35541 if (jj_scan_token(7)) return true;
35542 xsp = jj_scanpos;
35543 if (jj_3R_622()) jj_scanpos = xsp;
35544 return false;
35545 }
35546
35547 private boolean jj_3R_119() {
35548 if (jj_3R_124()) return true;
35549 if (jj_scan_token(EXCEPTION)) return true;
35550 if (jj_scan_token(4)) return true;
35551 return false;
35552 }
35553
35554 private boolean jj_3R_518() {
35555 if (jj_3R_182()) return true;
35556 return false;
35557 }
35558
35559 private boolean jj_3R_421() {
35560 if (jj_scan_token(PRAGMA)) return true;
35561 if (jj_scan_token(INLINE)) return true;
35562 if (jj_scan_token(5)) return true;
35563 if (jj_3R_128()) return true;
35564 if (jj_scan_token(6)) return true;
35565 if (jj_3R_182()) return true;
35566 if (jj_scan_token(7)) return true;
35567 return false;
35568 }
35569
35570 private boolean jj_3R_517() {
35571 if (jj_3R_124()) return true;
35572 return false;
35573 }
35574
35575 private boolean jj_3R_468() {
35576 if (jj_3R_128()) return true;
35577 if (jj_scan_token(5)) return true;
35578 if (jj_3R_490()) return true;
35579 return false;
35580 }
35581
35582 private boolean jj_3R_467() {
35583 if (jj_scan_token(INTERFACE)) return true;
35584 if (jj_scan_token(5)) return true;
35585 if (jj_scan_token(IDENTIFIER)) return true;
35586 if (jj_scan_token(6)) return true;
35587 if (jj_3R_124()) return true;
35588 Token xsp;
35589 xsp = jj_scanpos;
35590 if (jj_3R_489()) jj_scanpos = xsp;
35591 if (jj_scan_token(7)) return true;
35592 return false;
35593 }
35594
35595 private boolean jj_3_34() {
35596 if (jj_scan_token(5)) return true;
35597 if (jj_3R_127()) return true;
35598 if (jj_scan_token(7)) return true;
35599 return false;
35600 }
35601
35602 private boolean jj_3R_466() {
35603 if (jj_scan_token(EXCEPTION_INIT)) return true;
35604 if (jj_scan_token(5)) return true;
35605 if (jj_scan_token(IDENTIFIER)) return true;
35606 if (jj_scan_token(6)) return true;
35607 Token xsp;
35608 xsp = jj_scanpos;
35609 if (jj_3R_488()) jj_scanpos = xsp;
35610 if (jj_3R_127()) return true;
35611 if (jj_scan_token(7)) return true;
35612 return false;
35613 }
35614
35615 private boolean jj_3R_487() {
35616 if (jj_scan_token(6)) return true;
35617 Token xsp;
35618 xsp = jj_scanpos;
35619 if (jj_3R_517()) {
35620 jj_scanpos = xsp;
35621 if (jj_3R_518()) return true;
35622 }
35623 return false;
35624 }
35625
35626 private boolean jj_3R_465() {
35627 if (jj_scan_token(RESTRICT_REFERENCES)) return true;
35628 if (jj_scan_token(5)) return true;
35629 if (jj_3R_124()) return true;
35630 Token xsp;
35631 if (jj_3R_487()) return true;
35632 while (true) {
35633 xsp = jj_scanpos;
35634 if (jj_3R_487()) { jj_scanpos = xsp; break; }
35635 }
35636 if (jj_scan_token(7)) return true;
35637 return false;
35638 }
35639
35640 private boolean jj_3R_464() {
35641 if (jj_scan_token(TIMESTAMP)) return true;
35642 if (jj_scan_token(5)) return true;
35643 if (jj_3R_182()) return true;
35644 if (jj_scan_token(7)) return true;
35645 return false;
35646 }
35647
35648 private boolean jj_3R_392() {
35649 Token xsp;
35650 xsp = jj_scanpos;
35651 if (jj_scan_token(149)) {
35652 jj_scanpos = xsp;
35653 if (jj_scan_token(275)) {
35654 jj_scanpos = xsp;
35655 if (jj_scan_token(88)) return true;
35656 }
35657 }
35658 xsp = jj_scanpos;
35659 if (jj_3R_431()) {
35660 jj_scanpos = xsp;
35661 if (jj_3R_432()) return true;
35662 }
35663 xsp = jj_scanpos;
35664 if (jj_3R_433()) jj_scanpos = xsp;
35665 xsp = jj_scanpos;
35666 if (jj_3_39()) jj_scanpos = xsp;
35667 xsp = jj_scanpos;
35668 if (jj_3R_434()) jj_scanpos = xsp;
35669 return false;
35670 }
35671
35672 private boolean jj_3R_422() {
35673 if (jj_scan_token(PRAGMA)) return true;
35674 Token xsp;
35675 xsp = jj_scanpos;
35676 if (jj_scan_token(38)) {
35677 jj_scanpos = xsp;
35678 if (jj_scan_token(41)) {
35679 jj_scanpos = xsp;
35680 if (jj_3R_464()) {
35681 jj_scanpos = xsp;
35682 if (jj_3R_465()) {
35683 jj_scanpos = xsp;
35684 if (jj_3R_466()) {
35685 jj_scanpos = xsp;
35686 if (jj_3R_467()) {
35687 jj_scanpos = xsp;
35688 if (jj_3R_468()) return true;
35689 }
35690 }
35691 }
35692 }
35693 }
35694 }
35695 if (jj_scan_token(4)) return true;
35696 return false;
35697 }
35698
35699 private boolean jj_3_38() {
35700 if (jj_scan_token(TO)) return true;
35701 if (jj_scan_token(SECOND)) return true;
35702 Token xsp;
35703 xsp = jj_scanpos;
35704 if (jj_3_34()) jj_scanpos = xsp;
35705 return false;
35706 }
35707
35708 private boolean jj_3_37() {
35709 if (jj_scan_token(TO)) return true;
35710 if (jj_scan_token(MONTH)) return true;
35711 return false;
35712 }
35713
35714 private boolean jj_3_36() {
35715 if (jj_scan_token(WITH)) return true;
35716 if (jj_scan_token(TIME)) return true;
35717 if (jj_scan_token(ZONE)) return true;
35718 return false;
35719 }
35720
35721 private boolean jj_3_35() {
35722 if (jj_scan_token(WITH)) return true;
35723 if (jj_scan_token(LOCAL)) return true;
35724 if (jj_scan_token(TIME)) return true;
35725 if (jj_scan_token(ZONE)) return true;
35726 return false;
35727 }
35728
35729 private boolean jj_3R_206() {
35730 Token xsp;
35731 xsp = jj_scanpos;
35732 if (jj_3R_290()) {
35733 jj_scanpos = xsp;
35734 if (jj_3_35()) {
35735 jj_scanpos = xsp;
35736 if (jj_3_36()) {
35737 jj_scanpos = xsp;
35738 if (jj_3_37()) {
35739 jj_scanpos = xsp;
35740 if (jj_3_38()) return true;
35741 }
35742 }
35743 }
35744 }
35745 return false;
35746 }
35747
35748 private boolean jj_3R_290() {
35749 if (jj_scan_token(CHARACTER)) return true;
35750 if (jj_scan_token(SET)) return true;
35751 if (jj_3R_294()) return true;
35752 return false;
35753 }
35754
35755 private boolean jj_3R_440() {
35756 if (jj_scan_token(BYTE)) return true;
35757 return false;
35758 }
35759
35760 private boolean jj_3R_439() {
35761 if (jj_scan_token(CHAR)) return true;
35762 return false;
35763 }
35764
35765 private boolean jj_3R_121() {
35766 if (jj_3R_197()) return true;
35767 if (jj_scan_token(4)) return true;
35768 return false;
35769 }
35770
35771 private boolean jj_3R_438() {
35772 if (jj_scan_token(6)) return true;
35773 if (jj_3R_483()) return true;
35774 return false;
35775 }
35776
35777 private boolean jj_3R_568() {
35778 if (jj_scan_token(USING)) return true;
35779 Token xsp;
35780 xsp = jj_scanpos;
35781 if (jj_scan_token(401)) {
35782 jj_scanpos = xsp;
35783 if (jj_scan_token(402)) return true;
35784 }
35785 return false;
35786 }
35787
35788 private boolean jj_3_33() {
35789 if (jj_scan_token(5)) return true;
35790 if (jj_3R_127()) return true;
35791 Token xsp;
35792 xsp = jj_scanpos;
35793 if (jj_3R_438()) jj_scanpos = xsp;
35794 xsp = jj_scanpos;
35795 if (jj_3R_439()) jj_scanpos = xsp;
35796 xsp = jj_scanpos;
35797 if (jj_3R_440()) jj_scanpos = xsp;
35798 if (jj_scan_token(7)) return true;
35799 return false;
35800 }
35801
35802 private boolean jj_3_58() {
35803 if (jj_3R_142()) return true;
35804 Token xsp;
35805 xsp = jj_scanpos;
35806 if (jj_scan_token(23)) {
35807 jj_scanpos = xsp;
35808 if (jj_scan_token(51)) return true;
35809 }
35810 return false;
35811 }
35812
35813 private boolean jj_3R_435() {
35814 Token xsp;
35815 xsp = jj_scanpos;
35816 if (jj_3_58()) jj_scanpos = xsp;
35817 if (jj_3R_233()) return true;
35818 xsp = jj_scanpos;
35819 if (jj_3R_568()) jj_scanpos = xsp;
35820 return false;
35821 }
35822
35823 private boolean jj_3R_205() {
35824 if (jj_scan_token(SELF)) return true;
35825 if (jj_scan_token(AS)) return true;
35826 if (jj_scan_token(RESULT)) return true;
35827 return false;
35828 }
35829
35830 private boolean jj_3R_202() {
35831 if (jj_scan_token(DOUBLE)) return true;
35832 if (jj_scan_token(PRECISION)) return true;
35833 return false;
35834 }
35835
35836 private boolean jj_3_32() {
35837 if (jj_scan_token(INTERVAL)) return true;
35838 if (jj_scan_token(DAY)) return true;
35839 return false;
35840 }
35841
35842 private boolean jj_3_31() {
35843 if (jj_scan_token(INTERVAL)) return true;
35844 if (jj_scan_token(YEAR)) return true;
35845 return false;
35846 }
35847
35848 private boolean jj_3R_204() {
35849 if (jj_scan_token(REF)) return true;
35850 if (jj_scan_token(CURSOR)) return true;
35851 return false;
35852 }
35853
35854 private boolean jj_3R_535() {
35855 if (jj_scan_token(6)) return true;
35856 if (jj_3R_435()) return true;
35857 return false;
35858 }
35859
35860 private boolean jj_3R_393() {
35861 if (jj_3R_435()) return true;
35862 Token xsp;
35863 while (true) {
35864 xsp = jj_scanpos;
35865 if (jj_3R_535()) { jj_scanpos = xsp; break; }
35866 }
35867 return false;
35868 }
35869
35870 private boolean jj_3_30() {
35871 if (jj_scan_token(LONG)) return true;
35872 if (jj_scan_token(RAW)) return true;
35873 return false;
35874 }
35875
35876 private boolean jj_3R_341() {
35877 if (jj_3R_393()) return true;
35878 return false;
35879 }
35880
35881 private boolean jj_3R_141() {
35882 if (jj_scan_token(11)) return true;
35883 return false;
35884 }
35885
35886 private boolean jj_3R_282() {
35887 Token xsp;
35888 xsp = jj_scanpos;
35889 if (jj_scan_token(117)) {
35890 jj_scanpos = xsp;
35891 if (jj_scan_token(283)) {
35892 jj_scanpos = xsp;
35893 if (jj_scan_token(296)) {
35894 jj_scanpos = xsp;
35895 if (jj_scan_token(377)) {
35896 jj_scanpos = xsp;
35897 if (jj_scan_token(44)) {
35898 jj_scanpos = xsp;
35899 if (jj_scan_token(321)) {
35900 jj_scanpos = xsp;
35901 if (jj_scan_token(45)) {
35902 jj_scanpos = xsp;
35903 if (jj_scan_token(344)) {
35904 jj_scanpos = xsp;
35905 if (jj_scan_token(345)) {
35906 jj_scanpos = xsp;
35907 if (jj_scan_token(53)) {
35908 jj_scanpos = xsp;
35909 if (jj_scan_token(389)) {
35910 jj_scanpos = xsp;
35911 if (jj_scan_token(54)) {
35912 jj_scanpos = xsp;
35913 if (jj_scan_token(346)) {
35914 jj_scanpos = xsp;
35915 if (jj_scan_token(408)) {
35916 jj_scanpos = xsp;
35917 if (jj_scan_token(55)) {
35918 jj_scanpos = xsp;
35919 if (jj_scan_token(322)) {
35920 jj_scanpos = xsp;
35921 if (jj_scan_token(312)) {
35922 jj_scanpos = xsp;
35923 if (jj_scan_token(313)) {
35924 jj_scanpos = xsp;
35925 if (jj_scan_token(395)) {
35926 jj_scanpos = xsp;
35927 if (jj_scan_token(62)) {
35928 jj_scanpos = xsp;
35929 if (jj_scan_token(64)) {
35930 jj_scanpos = xsp;
35931 if (jj_scan_token(349)) {
35932 jj_scanpos = xsp;
35933 if (jj_scan_token(65)) {
35934 jj_scanpos = xsp;
35935 if (jj_scan_token(390)) {
35936 jj_scanpos = xsp;
35937 if (jj_scan_token(401)) {
35938 jj_scanpos = xsp;
35939 if (jj_scan_token(320)) {
35940 jj_scanpos = xsp;
35941 if (jj_scan_token(376)) {
35942 jj_scanpos = xsp;
35943 if (jj_scan_token(375)) {
35944 jj_scanpos = xsp;
35945 if (jj_scan_token(314)) {
35946 jj_scanpos = xsp;
35947 if (jj_scan_token(70)) {
35948 jj_scanpos = xsp;
35949 if (jj_scan_token(72)) {
35950 jj_scanpos = xsp;
35951 if (jj_scan_token(73)) {
35952 jj_scanpos = xsp;
35953 if (jj_scan_token(74)) {
35954 jj_scanpos = xsp;
35955 if (jj_scan_token(75)) {
35956 jj_scanpos = xsp;
35957 if (jj_scan_token(76)) {
35958 jj_scanpos = xsp;
35959 if (jj_scan_token(347)) {
35960 jj_scanpos = xsp;
35961 if (jj_scan_token(80)) {
35962 jj_scanpos = xsp;
35963 if (jj_scan_token(370)) {
35964 jj_scanpos = xsp;
35965 if (jj_scan_token(81)) {
35966 jj_scanpos = xsp;
35967 if (jj_scan_token(82)) {
35968 jj_scanpos = xsp;
35969 if (jj_scan_token(379)) {
35970 jj_scanpos = xsp;
35971 if (jj_scan_token(84)) {
35972 jj_scanpos = xsp;
35973 if (jj_scan_token(37)) {
35974 jj_scanpos = xsp;
35975 if (jj_scan_token(86)) {
35976 jj_scanpos = xsp;
35977 if (jj_scan_token(87)) {
35978 jj_scanpos = xsp;
35979 if (jj_scan_token(348)) {
35980 jj_scanpos = xsp;
35981 if (jj_scan_token(89)) {
35982 jj_scanpos = xsp;
35983 if (jj_scan_token(406)) {
35984 jj_scanpos = xsp;
35985 if (jj_scan_token(350)) {
35986 jj_scanpos = xsp;
35987 if (jj_scan_token(301)) {
35988 jj_scanpos = xsp;
35989 if (jj_scan_token(380)) {
35990 jj_scanpos = xsp;
35991 if (jj_scan_token(36)) {
35992 jj_scanpos = xsp;
35993 if (jj_scan_token(411)) {
35994 jj_scanpos = xsp;
35995 if (jj_scan_token(96)) {
35996 jj_scanpos = xsp;
35997 if (jj_scan_token(351)) {
35998 jj_scanpos = xsp;
35999 if (jj_scan_token(381)) {
36000 jj_scanpos = xsp;
36001 if (jj_scan_token(300)) {
36002 jj_scanpos = xsp;
36003 if (jj_scan_token(352)) {
36004 jj_scanpos = xsp;
36005 if (jj_scan_token(101)) {
36006 jj_scanpos = xsp;
36007 if (jj_scan_token(396)) {
36008 jj_scanpos = xsp;
36009 if (jj_scan_token(104)) {
36010 jj_scanpos = xsp;
36011 if (jj_scan_token(106)) {
36012 jj_scanpos = xsp;
36013 if (jj_scan_token(107)) {
36014 jj_scanpos = xsp;
36015 if (jj_scan_token(109)) {
36016 jj_scanpos = xsp;
36017 if (jj_scan_token(113)) {
36018 jj_scanpos = xsp;
36019 if (jj_scan_token(115)) {
36020 jj_scanpos = xsp;
36021 if (jj_scan_token(114)) {
36022 jj_scanpos = xsp;
36023 if (jj_scan_token(116)) {
36024 jj_scanpos = xsp;
36025 if (jj_scan_token(119)) {
36026 jj_scanpos = xsp;
36027 if (jj_scan_token(353)) {
36028 jj_scanpos = xsp;
36029 if (jj_scan_token(123)) {
36030 jj_scanpos = xsp;
36031 if (jj_scan_token(125)) {
36032 jj_scanpos = xsp;
36033 if (jj_scan_token(126)) {
36034 jj_scanpos = xsp;
36035 if (jj_scan_token(130)) {
36036 jj_scanpos = xsp;
36037 if (jj_scan_token(132)) {
36038 jj_scanpos = xsp;
36039 if (jj_scan_token(382)) {
36040 jj_scanpos = xsp;
36041 if (jj_scan_token(133)) {
36042 jj_scanpos = xsp;
36043 if (jj_scan_token(136)) {
36044 jj_scanpos = xsp;
36045 if (jj_scan_token(142)) {
36046 jj_scanpos = xsp;
36047 if (jj_scan_token(143)) {
36048 jj_scanpos = xsp;
36049 if (jj_scan_token(140)) {
36050 jj_scanpos = xsp;
36051 if (jj_scan_token(145)) {
36052 jj_scanpos = xsp;
36053 if (jj_scan_token(149)) {
36054 jj_scanpos = xsp;
36055 if (jj_scan_token(151)) {
36056 jj_scanpos = xsp;
36057 if (jj_scan_token(153)) {
36058 jj_scanpos = xsp;
36059 if (jj_scan_token(154)) {
36060 jj_scanpos = xsp;
36061 if (jj_scan_token(42)) {
36062 jj_scanpos = xsp;
36063 if (jj_scan_token(399)) {
36064 jj_scanpos = xsp;
36065 if (jj_scan_token(393)) {
36066 jj_scanpos = xsp;
36067 if (jj_scan_token(372)) {
36068 jj_scanpos = xsp;
36069 if (jj_scan_token(155)) {
36070 jj_scanpos = xsp;
36071 if (jj_scan_token(367)) {
36072 jj_scanpos = xsp;
36073 if (jj_scan_token(157)) {
36074 jj_scanpos = xsp;
36075 if (jj_scan_token(409)) {
36076 jj_scanpos = xsp;
36077 if (jj_scan_token(317)) {
36078 jj_scanpos = xsp;
36079 if (jj_scan_token(354)) {
36080 jj_scanpos = xsp;
36081 if (jj_scan_token(355)) {
36082 jj_scanpos = xsp;
36083 if (jj_scan_token(162)) {
36084 jj_scanpos = xsp;
36085 if (jj_scan_token(163)) {
36086 jj_scanpos = xsp;
36087 if (jj_scan_token(374)) {
36088 jj_scanpos = xsp;
36089 if (jj_scan_token(164)) {
36090 jj_scanpos = xsp;
36091 if (jj_scan_token(165)) {
36092 jj_scanpos = xsp;
36093 if (jj_scan_token(166)) {
36094 jj_scanpos = xsp;
36095 if (jj_scan_token(168)) {
36096 jj_scanpos = xsp;
36097 if (jj_scan_token(169)) {
36098 jj_scanpos = xsp;
36099 if (jj_scan_token(170)) {
36100 jj_scanpos = xsp;
36101 if (jj_scan_token(173)) {
36102 jj_scanpos = xsp;
36103 if (jj_scan_token(397)) {
36104 jj_scanpos = xsp;
36105 if (jj_scan_token(368)) {
36106 jj_scanpos = xsp;
36107 if (jj_scan_token(174)) {
36108 jj_scanpos = xsp;
36109 if (jj_scan_token(306)) {
36110 jj_scanpos = xsp;
36111 if (jj_scan_token(402)) {
36112 jj_scanpos = xsp;
36113 if (jj_scan_token(315)) {
36114 jj_scanpos = xsp;
36115 if (jj_scan_token(356)) {
36116 jj_scanpos = xsp;
36117 if (jj_scan_token(176)) {
36118 jj_scanpos = xsp;
36119 if (jj_scan_token(179)) {
36120 jj_scanpos = xsp;
36121 if (jj_scan_token(357)) {
36122 jj_scanpos = xsp;
36123 if (jj_scan_token(304)) {
36124 jj_scanpos = xsp;
36125 if (jj_scan_token(307)) {
36126 jj_scanpos = xsp;
36127 if (jj_scan_token(193)) {
36128 jj_scanpos = xsp;
36129 if (jj_scan_token(196)) {
36130 jj_scanpos = xsp;
36131 if (jj_scan_token(326)) {
36132 jj_scanpos = xsp;
36133 if (jj_scan_token(199)) {
36134 jj_scanpos = xsp;
36135 if (jj_scan_token(200)) {
36136 jj_scanpos = xsp;
36137 if (jj_scan_token(205)) {
36138 jj_scanpos = xsp;
36139 if (jj_scan_token(206)) {
36140 jj_scanpos = xsp;
36141 if (jj_scan_token(208)) {
36142 jj_scanpos = xsp;
36143 if (jj_scan_token(209)) {
36144 jj_scanpos = xsp;
36145 if (jj_scan_token(371)) {
36146 jj_scanpos = xsp;
36147 if (jj_scan_token(327)) {
36148 jj_scanpos = xsp;
36149 if (jj_scan_token(211)) {
36150 jj_scanpos = xsp;
36151 if (jj_scan_token(302)) {
36152 jj_scanpos = xsp;
36153 if (jj_scan_token(219)) {
36154 jj_scanpos = xsp;
36155 if (jj_scan_token(383)) {
36156 jj_scanpos = xsp;
36157 if (jj_scan_token(223)) {
36158 jj_scanpos = xsp;
36159 if (jj_scan_token(384)) {
36160 jj_scanpos = xsp;
36161 if (jj_scan_token(226)) {
36162 jj_scanpos = xsp;
36163 if (jj_scan_token(228)) {
36164 jj_scanpos = xsp;
36165 if (jj_scan_token(229)) {
36166 jj_scanpos = xsp;
36167 if (jj_scan_token(230)) {
36168 jj_scanpos = xsp;
36169 if (jj_scan_token(232)) {
36170 jj_scanpos = xsp;
36171 if (jj_scan_token(385)) {
36172 jj_scanpos = xsp;
36173 if (jj_scan_token(235)) {
36174 jj_scanpos = xsp;
36175 if (jj_scan_token(237)) {
36176 jj_scanpos = xsp;
36177 if (jj_scan_token(238)) {
36178 jj_scanpos = xsp;
36179 if (jj_scan_token(239)) {
36180 jj_scanpos = xsp;
36181 if (jj_scan_token(394)) {
36182 jj_scanpos = xsp;
36183 if (jj_scan_token(241)) {
36184 jj_scanpos = xsp;
36185 if (jj_scan_token(242)) {
36186 jj_scanpos = xsp;
36187 if (jj_scan_token(244)) {
36188 jj_scanpos = xsp;
36189 if (jj_scan_token(245)) {
36190 jj_scanpos = xsp;
36191 if (jj_scan_token(243)) {
36192 jj_scanpos = xsp;
36193 if (jj_scan_token(247)) {
36194 jj_scanpos = xsp;
36195 if (jj_scan_token(248)) {
36196 jj_scanpos = xsp;
36197 if (jj_scan_token(358)) {
36198 jj_scanpos = xsp;
36199 if (jj_scan_token(249)) {
36200 jj_scanpos = xsp;
36201 if (jj_scan_token(251)) {
36202 jj_scanpos = xsp;
36203 if (jj_scan_token(359)) {
36204 jj_scanpos = xsp;
36205 if (jj_scan_token(407)) {
36206 jj_scanpos = xsp;
36207 if (jj_scan_token(253)) {
36208 jj_scanpos = xsp;
36209 if (jj_scan_token(410)) {
36210 jj_scanpos = xsp;
36211 if (jj_scan_token(360)) {
36212 jj_scanpos = xsp;
36213 if (jj_scan_token(257)) {
36214 jj_scanpos = xsp;
36215 if (jj_scan_token(361)) {
36216 jj_scanpos = xsp;
36217 if (jj_scan_token(362)) {
36218 jj_scanpos = xsp;
36219 if (jj_scan_token(262)) {
36220 jj_scanpos = xsp;
36221 if (jj_scan_token(363)) {
36222 jj_scanpos = xsp;
36223 if (jj_scan_token(369)) {
36224 jj_scanpos = xsp;
36225 if (jj_scan_token(398)) {
36226 jj_scanpos = xsp;
36227 if (jj_scan_token(265)) {
36228 jj_scanpos = xsp;
36229 if (jj_scan_token(264)) {
36230 jj_scanpos = xsp;
36231 if (jj_scan_token(266)) {
36232 jj_scanpos = xsp;
36233 if (jj_scan_token(364)) {
36234 jj_scanpos = xsp;
36235 if (jj_scan_token(373)) {
36236 jj_scanpos = xsp;
36237 if (jj_scan_token(272)) {
36238 jj_scanpos = xsp;
36239 if (jj_scan_token(274)) {
36240 jj_scanpos = xsp;
36241 if (jj_scan_token(275)) {
36242 jj_scanpos = xsp;
36243 if (jj_scan_token(277)) {
36244 jj_scanpos = xsp;
36245 if (jj_scan_token(279)) {
36246 jj_scanpos = xsp;
36247 if (jj_scan_token(278)) {
36248 jj_scanpos = xsp;
36249 if (jj_scan_token(276)) {
36250 jj_scanpos = xsp;
36251 if (jj_scan_token(400)) {
36252 jj_scanpos = xsp;
36253 if (jj_scan_token(281)) {
36254 jj_scanpos = xsp;
36255 if (jj_scan_token(391)) {
36256 jj_scanpos = xsp;
36257 if (jj_scan_token(392)) {
36258 jj_scanpos = xsp;
36259 if (jj_scan_token(365)) {
36260 jj_scanpos = xsp;
36261 if (jj_scan_token(386)) {
36262 jj_scanpos = xsp;
36263 if (jj_scan_token(286)) {
36264 jj_scanpos = xsp;
36265 if (jj_scan_token(309)) {
36266 jj_scanpos = xsp;
36267 if (jj_scan_token(412)) {
36268 jj_scanpos = xsp;
36269 if (jj_scan_token(288)) {
36270 jj_scanpos = xsp;
36271 if (jj_scan_token(310)) {
36272 jj_scanpos = xsp;
36273 if (jj_scan_token(387)) {
36274 jj_scanpos = xsp;
36275 if (jj_scan_token(311)) {
36276 jj_scanpos = xsp;
36277 if (jj_scan_token(388)) {
36278 jj_scanpos = xsp;
36279 if (jj_scan_token(316)) {
36280 jj_scanpos = xsp;
36281 if (jj_scan_token(293)) {
36282 jj_scanpos = xsp;
36283 if (jj_scan_token(319)) {
36284 jj_scanpos = xsp;
36285 if (jj_scan_token(294)) {
36286 jj_scanpos = xsp;
36287 if (jj_scan_token(366)) {
36288 jj_scanpos = xsp;
36289 if (jj_scan_token(270)) {
36290 jj_scanpos = xsp;
36291 if (jj_scan_token(100)) {
36292 jj_scanpos = xsp;
36293 if (jj_scan_token(182)) {
36294 jj_scanpos = xsp;
36295 if (jj_scan_token(378)) {
36296 jj_scanpos = xsp;
36297 if (jj_scan_token(186)) {
36298 jj_scanpos = xsp;
36299 if (jj_scan_token(233)) {
36300 jj_scanpos = xsp;
36301 if (jj_scan_token(231)) {
36302 jj_scanpos = xsp;
36303 if (jj_scan_token(43)) return true;
36304 }
36305 }
36306 }
36307 }
36308 }
36309 }
36310 }
36311 }
36312 }
36313 }
36314 }
36315 }
36316 }
36317 }
36318 }
36319 }
36320 }
36321 }
36322 }
36323 }
36324 }
36325 }
36326 }
36327 }
36328 }
36329 }
36330 }
36331 }
36332 }
36333 }
36334 }
36335 }
36336 }
36337 }
36338 }
36339 }
36340 }
36341 }
36342 }
36343 }
36344 }
36345 }
36346 }
36347 }
36348 }
36349 }
36350 }
36351 }
36352 }
36353 }
36354 }
36355 }
36356 }
36357 }
36358 }
36359 }
36360 }
36361 }
36362 }
36363 }
36364 }
36365 }
36366 }
36367 }
36368 }
36369 }
36370 }
36371 }
36372 }
36373 }
36374 }
36375 }
36376 }
36377 }
36378 }
36379 }
36380 }
36381 }
36382 }
36383 }
36384 }
36385 }
36386 }
36387 }
36388 }
36389 }
36390 }
36391 }
36392 }
36393 }
36394 }
36395 }
36396 }
36397 }
36398 }
36399 }
36400 }
36401 }
36402 }
36403 }
36404 }
36405 }
36406 }
36407 }
36408 }
36409 }
36410 }
36411 }
36412 }
36413 }
36414 }
36415 }
36416 }
36417 }
36418 }
36419 }
36420 }
36421 }
36422 }
36423 }
36424 }
36425 }
36426 }
36427 }
36428 }
36429 }
36430 }
36431 }
36432 }
36433 }
36434 }
36435 }
36436 }
36437 }
36438 }
36439 }
36440 }
36441 }
36442 }
36443 }
36444 }
36445 }
36446 }
36447 }
36448 }
36449 }
36450 }
36451 }
36452 }
36453 }
36454 }
36455 }
36456 }
36457 }
36458 }
36459 }
36460 }
36461 }
36462 }
36463 }
36464 }
36465 }
36466 }
36467 }
36468 }
36469 }
36470 }
36471 }
36472 }
36473 }
36474 }
36475 }
36476 }
36477 }
36478 }
36479 }
36480 }
36481 }
36482 }
36483 }
36484 }
36485 }
36486 }
36487 }
36488 }
36489 }
36490 }
36491 }
36492 }
36493 }
36494 }
36495 }
36496 }
36497 }
36498 }
36499 }
36500 }
36501 }
36502 }
36503 }
36504 }
36505 }
36506 }
36507 }
36508 }
36509 }
36510 }
36511 return false;
36512 }
36513
36514 private boolean jj_3R_298() {
36515 if (jj_scan_token(5)) return true;
36516 Token xsp;
36517 xsp = jj_scanpos;
36518 if (jj_3R_341()) jj_scanpos = xsp;
36519 if (jj_scan_token(7)) return true;
36520 return false;
36521 }
36522
36523 private boolean jj_3R_352() {
36524 if (jj_scan_token(3)) return true;
36525 if (jj_3R_120()) return true;
36526 return false;
36527 }
36528
36529 private boolean jj_3R_203() {
36530 Token xsp;
36531 xsp = jj_scanpos;
36532 if (jj_scan_token(67)) {
36533 jj_scanpos = xsp;
36534 if (jj_scan_token(320)) {
36535 jj_scanpos = xsp;
36536 if (jj_3_30()) {
36537 jj_scanpos = xsp;
36538 if (jj_scan_token(160)) {
36539 jj_scanpos = xsp;
36540 if (jj_scan_token(306)) {
36541 jj_scanpos = xsp;
36542 if (jj_scan_token(307)) {
36543 jj_scanpos = xsp;
36544 if (jj_scan_token(227)) {
36545 jj_scanpos = xsp;
36546 if (jj_scan_token(244)) {
36547 jj_scanpos = xsp;
36548 if (jj_scan_token(308)) {
36549 jj_scanpos = xsp;
36550 if (jj_scan_token(309)) {
36551 jj_scanpos = xsp;
36552 if (jj_scan_token(298)) {
36553 jj_scanpos = xsp;
36554 if (jj_scan_token(299)) {
36555 jj_scanpos = xsp;
36556 if (jj_scan_token(314)) {
36557 jj_scanpos = xsp;
36558 if (jj_scan_token(315)) return true;
36559 }
36560 }
36561 }
36562 }
36563 }
36564 }
36565 }
36566 }
36567 }
36568 }
36569 }
36570 }
36571 }
36572 return false;
36573 }
36574
36575 private boolean jj_3R_128() {
36576 if (jj_3R_142()) return true;
36577 Token xsp;
36578 while (true) {
36579 xsp = jj_scanpos;
36580 if (jj_3R_352()) { jj_scanpos = xsp; break; }
36581 }
36582 return false;
36583 }
36584
36585 private boolean jj_3R_126() {
36586 Token xsp;
36587 xsp = jj_scanpos;
36588 if (jj_scan_token(188)) {
36589 jj_scanpos = xsp;
36590 if (jj_scan_token(189)) {
36591 jj_scanpos = xsp;
36592 if (jj_scan_token(68)) {
36593 jj_scanpos = xsp;
36594 if (jj_scan_token(190)) {
36595 jj_scanpos = xsp;
36596 if (jj_scan_token(191)) {
36597 jj_scanpos = xsp;
36598 if (jj_scan_token(192)) {
36599 jj_scanpos = xsp;
36600 if (jj_scan_token(59)) {
36601 jj_scanpos = xsp;
36602 if (jj_scan_token(301)) {
36603 jj_scanpos = xsp;
36604 if (jj_scan_token(91)) {
36605 jj_scanpos = xsp;
36606 if (jj_3R_202()) {
36607 jj_scanpos = xsp;
36608 if (jj_scan_token(120)) {
36609 jj_scanpos = xsp;
36610 if (jj_scan_token(303)) {
36611 jj_scanpos = xsp;
36612 if (jj_scan_token(146)) {
36613 jj_scanpos = xsp;
36614 if (jj_scan_token(174)) {
36615 jj_scanpos = xsp;
36616 if (jj_scan_token(175)) {
36617 jj_scanpos = xsp;
36618 if (jj_scan_token(187)) {
36619 jj_scanpos = xsp;
36620 if (jj_scan_token(304)) {
36621 jj_scanpos = xsp;
36622 if (jj_scan_token(215)) {
36623 jj_scanpos = xsp;
36624 if (jj_scan_token(216)) {
36625 jj_scanpos = xsp;
36626 if (jj_scan_token(217)) {
36627 jj_scanpos = xsp;
36628 if (jj_scan_token(228)) {
36629 jj_scanpos = xsp;
36630 if (jj_scan_token(305)) {
36631 jj_scanpos = xsp;
36632 if (jj_scan_token(256)) {
36633 jj_scanpos = xsp;
36634 if (jj_3R_203()) {
36635 jj_scanpos = xsp;
36636 if (jj_scan_token(61)) {
36637 jj_scanpos = xsp;
36638 if (jj_scan_token(312)) {
36639 jj_scanpos = xsp;
36640 if (jj_scan_token(313)) {
36641 jj_scanpos = xsp;
36642 if (jj_scan_token(270)) {
36643 jj_scanpos = xsp;
36644 if (jj_3R_204()) {
36645 jj_scanpos = xsp;
36646 if (jj_scan_token(88)) {
36647 jj_scanpos = xsp;
36648 if (jj_3_31()) {
36649 jj_scanpos = xsp;
36650 if (jj_3_32()) {
36651 jj_scanpos = xsp;
36652 if (jj_scan_token(274)) {
36653 jj_scanpos = xsp;
36654 if (jj_scan_token(275)) {
36655 jj_scanpos = xsp;
36656 if (jj_3R_205()) return true;
36657 }
36658 }
36659 }
36660 }
36661 }
36662 }
36663 }
36664 }
36665 }
36666 }
36667 }
36668 }
36669 }
36670 }
36671 }
36672 }
36673 }
36674 }
36675 }
36676 }
36677 }
36678 }
36679 }
36680 }
36681 }
36682 }
36683 }
36684 }
36685 }
36686 }
36687 }
36688 }
36689 }
36690 }
36691 xsp = jj_scanpos;
36692 if (jj_3_33()) jj_scanpos = xsp;
36693 xsp = jj_scanpos;
36694 if (jj_3R_206()) jj_scanpos = xsp;
36695 return false;
36696 }
36697
36698 private boolean jj_3R_239() {
36699 if (jj_scan_token(VARYING)) return true;
36700 if (jj_scan_token(ARRAY)) return true;
36701 return false;
36702 }
36703
36704 private boolean jj_3R_140() {
36705 if (jj_scan_token(3)) return true;
36706 return false;
36707 }
36708
36709 private boolean jj_3_57() {
36710 Token xsp;
36711 xsp = jj_scanpos;
36712 if (jj_3R_140()) {
36713 jj_scanpos = xsp;
36714 if (jj_3R_141()) return true;
36715 }
36716 if (jj_3R_120()) return true;
36717 return false;
36718 }
36719
36720 private boolean jj_3R_294() {
36721 if (jj_3R_142()) return true;
36722 Token xsp;
36723 while (true) {
36724 xsp = jj_scanpos;
36725 if (jj_3_57()) { jj_scanpos = xsp; break; }
36726 }
36727 return false;
36728 }
36729
36730 private boolean jj_3_29() {
36731 if (jj_scan_token(5)) return true;
36732 if (jj_3R_127()) return true;
36733 return false;
36734 }
36735
36736 private boolean jj_3R_190() {
36737 if (jj_scan_token(21)) return true;
36738 if (jj_3R_142()) return true;
36739 if (jj_scan_token(22)) return true;
36740 return false;
36741 }
36742
36743 private boolean jj_3R_145() {
36744 Token xsp;
36745 xsp = jj_scanpos;
36746 if (jj_scan_token(271)) {
36747 jj_scanpos = xsp;
36748 if (jj_scan_token(310)) {
36749 jj_scanpos = xsp;
36750 if (jj_3R_239()) return true;
36751 }
36752 }
36753 xsp = jj_scanpos;
36754 if (jj_3_29()) jj_scanpos = xsp;
36755 return false;
36756 }
36757
36758 private boolean jj_3R_399() {
36759 if (jj_scan_token(CC_ELSE)) return true;
36760 if (jj_3R_235()) return true;
36761 return false;
36762 }
36763
36764 private boolean jj_3R_127() {
36765 if (jj_scan_token(UNSIGNED_NUMERIC_LITERAL)) return true;
36766 return false;
36767 }
36768
36769 private boolean jj_3R_398() {
36770 if (jj_scan_token(CC_ELSIF)) return true;
36771 if (jj_3R_343()) return true;
36772 if (jj_scan_token(CC_THEN)) return true;
36773 if (jj_3R_235()) return true;
36774 return false;
36775 }
36776
36777 private boolean jj_3R_345() {
36778 if (jj_scan_token(CC_IF)) return true;
36779 if (jj_3R_343()) return true;
36780 if (jj_scan_token(CC_THEN)) return true;
36781 if (jj_3R_235()) return true;
36782 Token xsp;
36783 while (true) {
36784 xsp = jj_scanpos;
36785 if (jj_3R_398()) { jj_scanpos = xsp; break; }
36786 }
36787 while (true) {
36788 xsp = jj_scanpos;
36789 if (jj_3R_399()) { jj_scanpos = xsp; break; }
36790 }
36791 if (jj_scan_token(CC_END)) return true;
36792 return false;
36793 }
36794
36795 private boolean jj_3R_347() {
36796 if (jj_scan_token(11)) return true;
36797 Token xsp;
36798 xsp = jj_scanpos;
36799 if (jj_scan_token(284)) {
36800 jj_scanpos = xsp;
36801 if (jj_scan_token(246)) return true;
36802 }
36803 return false;
36804 }
36805
36806 private boolean jj_3R_346() {
36807 if (jj_scan_token(2)) return true;
36808 if (jj_3R_128()) return true;
36809 return false;
36810 }
36811
36812 private boolean jj_3_27() {
36813 if (jj_scan_token(REF)) return true;
36814 return false;
36815 }
36816
36817 private boolean jj_3R_226() {
36818 if (jj_scan_token(A)) return true;
36819 if (jj_scan_token(SET)) return true;
36820 return false;
36821 }
36822
36823 private boolean jj_3R_304() {
36824 Token xsp;
36825 xsp = jj_scanpos;
36826 if (jj_3_27()) jj_scanpos = xsp;
36827 if (jj_3R_128()) return true;
36828 xsp = jj_scanpos;
36829 if (jj_3R_346()) jj_scanpos = xsp;
36830 xsp = jj_scanpos;
36831 if (jj_3R_347()) jj_scanpos = xsp;
36832 return false;
36833 }
36834
36835 private boolean jj_3R_136() {
36836 Token xsp;
36837 xsp = jj_scanpos;
36838 if (jj_3R_226()) {
36839 jj_scanpos = xsp;
36840 if (jj_scan_token(396)) return true;
36841 }
36842 return false;
36843 }
36844
36845 private boolean jj_3_28() {
36846 if (jj_3R_126()) return true;
36847 return false;
36848 }
36849
36850 private boolean jj_3R_303() {
36851 if (jj_3R_345()) return true;
36852 return false;
36853 }
36854
36855 private boolean jj_3R_235() {
36856 Token xsp;
36857 xsp = jj_scanpos;
36858 if (jj_3R_303()) {
36859 jj_scanpos = xsp;
36860 if (jj_3_28()) {
36861 jj_scanpos = xsp;
36862 if (jj_3R_304()) return true;
36863 }
36864 }
36865 return false;
36866 }
36867
36868 private boolean jj_3R_391() {
36869 if (jj_scan_token(NULL)) return true;
36870 return false;
36871 }
36872
36873 private boolean jj_3R_334() {
36874 if (jj_scan_token(_DEFAULT)) return true;
36875 return false;
36876 }
36877
36878 private boolean jj_3R_390() {
36879 Token xsp;
36880 xsp = jj_scanpos;
36881 if (jj_scan_token(283)) {
36882 jj_scanpos = xsp;
36883 if (jj_scan_token(117)) return true;
36884 }
36885 return false;
36886 }
36887
36888 private boolean jj_3R_335() {
36889 if (jj_3R_233()) return true;
36890 return false;
36891 }
36892
36893 private boolean jj_3R_283() {
36894 if (jj_3R_124()) return true;
36895 return false;
36896 }
36897
36898 private boolean jj_3R_333() {
36899 if (jj_scan_token(9)) return true;
36900 if (jj_scan_token(10)) return true;
36901 return false;
36902 }
36903
36904 private boolean jj_3R_285() {
36905 Token xsp;
36906 xsp = jj_scanpos;
36907 if (jj_3R_333()) {
36908 jj_scanpos = xsp;
36909 if (jj_3R_334()) return true;
36910 }
36911 if (jj_3R_335()) return true;
36912 return false;
36913 }
36914
36915 private boolean jj_3R_332() {
36916 if (jj_scan_token(NOT)) return true;
36917 return false;
36918 }
36919
36920 private boolean jj_3R_284() {
36921 Token xsp;
36922 xsp = jj_scanpos;
36923 if (jj_3R_332()) jj_scanpos = xsp;
36924 if (jj_scan_token(NULL)) return true;
36925 return false;
36926 }
36927
36928 private boolean jj_3_26() {
36929 if (jj_scan_token(CONSTANT)) return true;
36930 return false;
36931 }
36932
36933 private boolean jj_3R_197() {
36934 if (jj_3R_283()) return true;
36935 Token xsp;
36936 xsp = jj_scanpos;
36937 if (jj_3_26()) jj_scanpos = xsp;
36938 if (jj_3R_235()) return true;
36939 xsp = jj_scanpos;
36940 if (jj_3R_284()) jj_scanpos = xsp;
36941 xsp = jj_scanpos;
36942 if (jj_3R_285()) jj_scanpos = xsp;
36943 return false;
36944 }
36945
36946 private boolean jj_3R_514() {
36947 if (jj_scan_token(6)) return true;
36948 if (jj_3R_474()) return true;
36949 return false;
36950 }
36951
36952 private boolean jj_3R_427() {
36953 if (jj_3R_474()) return true;
36954 Token xsp;
36955 while (true) {
36956 xsp = jj_scanpos;
36957 if (jj_3R_514()) { jj_scanpos = xsp; break; }
36958 }
36959 return false;
36960 }
36961
36962 private boolean jj_3R_385() {
36963 if (jj_scan_token(5)) return true;
36964 Token xsp;
36965 xsp = jj_scanpos;
36966 if (jj_3R_427()) jj_scanpos = xsp;
36967 if (jj_scan_token(7)) return true;
36968 return false;
36969 }
36970
36971 private boolean jj_3R_182() {
36972 if (jj_scan_token(STRING_LITERAL)) return true;
36973 return false;
36974 }
36975
36976 private boolean jj_3_23() {
36977 if (jj_scan_token(NOCOPY)) return true;
36978 return false;
36979 }
36980
36981 private boolean jj_3R_325() {
36982 if (jj_3R_385()) return true;
36983 return false;
36984 }
36985
36986 private boolean jj_3R_324() {
36987 if (jj_scan_token(RETURN)) return true;
36988 if (jj_3R_235()) return true;
36989 return false;
36990 }
36991
36992 private boolean jj_3R_278() {
36993 if (jj_scan_token(PROCEDURE)) return true;
36994 if (jj_3R_154()) return true;
36995 Token xsp;
36996 xsp = jj_scanpos;
36997 if (jj_3R_325()) jj_scanpos = xsp;
36998 return false;
36999 }
37000
37001 private boolean jj_3R_196() {
37002 if (jj_3R_282()) return true;
37003 return false;
37004 }
37005
37006 private boolean jj_3R_463() {
37007 if (jj_3R_124()) return true;
37008 return false;
37009 }
37010
37011 private boolean jj_3R_125() {
37012 if (jj_scan_token(IN)) return true;
37013 if (jj_scan_token(OUT)) return true;
37014 return false;
37015 }
37016
37017 private boolean jj_3R_340() {
37018 if (jj_3R_392()) return true;
37019 return false;
37020 }
37021
37022 private boolean jj_3R_339() {
37023 if (jj_3R_391()) return true;
37024 return false;
37025 }
37026
37027 private boolean jj_3R_338() {
37028 if (jj_3R_390()) return true;
37029 return false;
37030 }
37031
37032 private boolean jj_3R_337() {
37033 if (jj_3R_182()) return true;
37034 return false;
37035 }
37036
37037 private boolean jj_3R_323() {
37038 if (jj_3R_385()) return true;
37039 return false;
37040 }
37041
37042 private boolean jj_3R_120() {
37043 Token xsp;
37044 xsp = jj_scanpos;
37045 if (jj_scan_token(420)) {
37046 jj_scanpos = xsp;
37047 if (jj_scan_token(428)) {
37048 jj_scanpos = xsp;
37049 if (jj_3R_196()) {
37050 jj_scanpos = xsp;
37051 if (jj_scan_token(35)) {
37052 jj_scanpos = xsp;
37053 if (jj_scan_token(38)) {
37054 jj_scanpos = xsp;
37055 if (jj_scan_token(39)) {
37056 jj_scanpos = xsp;
37057 if (jj_scan_token(40)) {
37058 jj_scanpos = xsp;
37059 if (jj_scan_token(41)) {
37060 jj_scanpos = xsp;
37061 if (jj_scan_token(50)) {
37062 jj_scanpos = xsp;
37063 if (jj_scan_token(56)) {
37064 jj_scanpos = xsp;
37065 if (jj_scan_token(59)) {
37066 jj_scanpos = xsp;
37067 if (jj_scan_token(60)) {
37068 jj_scanpos = xsp;
37069 if (jj_scan_token(61)) {
37070 jj_scanpos = xsp;
37071 if (jj_scan_token(67)) {
37072 jj_scanpos = xsp;
37073 if (jj_scan_token(68)) {
37074 jj_scanpos = xsp;
37075 if (jj_scan_token(79)) {
37076 jj_scanpos = xsp;
37077 if (jj_scan_token(85)) {
37078 jj_scanpos = xsp;
37079 if (jj_scan_token(88)) {
37080 jj_scanpos = xsp;
37081 if (jj_scan_token(91)) {
37082 jj_scanpos = xsp;
37083 if (jj_scan_token(93)) {
37084 jj_scanpos = xsp;
37085 if (jj_scan_token(98)) {
37086 jj_scanpos = xsp;
37087 if (jj_scan_token(103)) {
37088 jj_scanpos = xsp;
37089 if (jj_scan_token(111)) {
37090 jj_scanpos = xsp;
37091 if (jj_scan_token(112)) {
37092 jj_scanpos = xsp;
37093 if (jj_scan_token(120)) {
37094 jj_scanpos = xsp;
37095 if (jj_scan_token(122)) {
37096 jj_scanpos = xsp;
37097 if (jj_scan_token(146)) {
37098 jj_scanpos = xsp;
37099 if (jj_scan_token(147)) {
37100 jj_scanpos = xsp;
37101 if (jj_scan_token(160)) {
37102 jj_scanpos = xsp;
37103 if (jj_scan_token(161)) {
37104 jj_scanpos = xsp;
37105 if (jj_scan_token(171)) {
37106 jj_scanpos = xsp;
37107 if (jj_scan_token(175)) {
37108 jj_scanpos = xsp;
37109 if (jj_scan_token(178)) {
37110 jj_scanpos = xsp;
37111 if (jj_scan_token(181)) {
37112 jj_scanpos = xsp;
37113 if (jj_scan_token(187)) {
37114 jj_scanpos = xsp;
37115 if (jj_scan_token(188)) {
37116 jj_scanpos = xsp;
37117 if (jj_scan_token(189)) {
37118 jj_scanpos = xsp;
37119 if (jj_scan_token(190)) {
37120 jj_scanpos = xsp;
37121 if (jj_scan_token(191)) {
37122 jj_scanpos = xsp;
37123 if (jj_scan_token(192)) {
37124 jj_scanpos = xsp;
37125 if (jj_scan_token(194)) {
37126 jj_scanpos = xsp;
37127 if (jj_scan_token(201)) {
37128 jj_scanpos = xsp;
37129 if (jj_scan_token(207)) {
37130 jj_scanpos = xsp;
37131 if (jj_scan_token(215)) {
37132 jj_scanpos = xsp;
37133 if (jj_scan_token(216)) {
37134 jj_scanpos = xsp;
37135 if (jj_scan_token(217)) {
37136 jj_scanpos = xsp;
37137 if (jj_scan_token(218)) {
37138 jj_scanpos = xsp;
37139 if (jj_scan_token(220)) {
37140 jj_scanpos = xsp;
37141 if (jj_scan_token(222)) {
37142 jj_scanpos = xsp;
37143 if (jj_scan_token(221)) {
37144 jj_scanpos = xsp;
37145 if (jj_scan_token(225)) {
37146 jj_scanpos = xsp;
37147 if (jj_scan_token(227)) {
37148 jj_scanpos = xsp;
37149 if (jj_scan_token(246)) {
37150 jj_scanpos = xsp;
37151 if (jj_scan_token(252)) {
37152 jj_scanpos = xsp;
37153 if (jj_scan_token(256)) {
37154 jj_scanpos = xsp;
37155 if (jj_scan_token(259)) {
37156 jj_scanpos = xsp;
37157 if (jj_scan_token(260)) {
37158 jj_scanpos = xsp;
37159 if (jj_scan_token(263)) {
37160 jj_scanpos = xsp;
37161 if (jj_scan_token(267)) {
37162 jj_scanpos = xsp;
37163 if (jj_scan_token(268)) {
37164 jj_scanpos = xsp;
37165 if (jj_scan_token(269)) {
37166 jj_scanpos = xsp;
37167 if (jj_scan_token(282)) {
37168 jj_scanpos = xsp;
37169 if (jj_scan_token(284)) {
37170 jj_scanpos = xsp;
37171 if (jj_scan_token(285)) {
37172 jj_scanpos = xsp;
37173 if (jj_scan_token(298)) {
37174 jj_scanpos = xsp;
37175 if (jj_scan_token(299)) {
37176 jj_scanpos = xsp;
37177 if (jj_scan_token(303)) {
37178 jj_scanpos = xsp;
37179 if (jj_scan_token(305)) {
37180 jj_scanpos = xsp;
37181 if (jj_scan_token(308)) {
37182 jj_scanpos = xsp;
37183 if (jj_scan_token(292)) return true;
37184 }
37185 }
37186 }
37187 }
37188 }
37189 }
37190 }
37191 }
37192 }
37193 }
37194 }
37195 }
37196 }
37197 }
37198 }
37199 }
37200 }
37201 }
37202 }
37203 }
37204 }
37205 }
37206 }
37207 }
37208 }
37209 }
37210 }
37211 }
37212 }
37213 }
37214 }
37215 }
37216 }
37217 }
37218 }
37219 }
37220 }
37221 }
37222 }
37223 }
37224 }
37225 }
37226 }
37227 }
37228 }
37229 }
37230 }
37231 }
37232 }
37233 }
37234 }
37235 }
37236 }
37237 }
37238 }
37239 }
37240 }
37241 }
37242 }
37243 }
37244 }
37245 }
37246 }
37247 }
37248 }
37249 }
37250 }
37251 }
37252 }
37253 return false;
37254 }
37255
37256 private boolean jj_3R_336() {
37257 if (jj_3R_127()) return true;
37258 return false;
37259 }
37260
37261 private boolean jj_3R_293() {
37262 Token xsp;
37263 xsp = jj_scanpos;
37264 if (jj_3R_336()) {
37265 jj_scanpos = xsp;
37266 if (jj_scan_token(425)) {
37267 jj_scanpos = xsp;
37268 if (jj_3R_337()) {
37269 jj_scanpos = xsp;
37270 if (jj_3R_338()) {
37271 jj_scanpos = xsp;
37272 if (jj_3R_339()) {
37273 jj_scanpos = xsp;
37274 if (jj_3R_340()) return true;
37275 }
37276 }
37277 }
37278 }
37279 }
37280 return false;
37281 }
37282
37283 private boolean jj_3R_478() {
37284 if (jj_3R_233()) return true;
37285 return false;
37286 }
37287
37288 private boolean jj_3R_277() {
37289 if (jj_scan_token(FUNCTION)) return true;
37290 if (jj_3R_154()) return true;
37291 Token xsp;
37292 xsp = jj_scanpos;
37293 if (jj_3R_323()) jj_scanpos = xsp;
37294 xsp = jj_scanpos;
37295 if (jj_3R_324()) jj_scanpos = xsp;
37296 return false;
37297 }
37298
37299 private boolean jj_3R_477() {
37300 if (jj_3R_182()) return true;
37301 return false;
37302 }
37303
37304 private boolean jj_3R_624() {
37305 if (jj_scan_token(3)) return true;
37306 if (jj_3R_124()) return true;
37307 return false;
37308 }
37309
37310 private boolean jj_3R_476() {
37311 if (jj_scan_token(SESSIONTIMEZONE)) return true;
37312 return false;
37313 }
37314
37315 private boolean jj_3R_193() {
37316 Token xsp;
37317 xsp = jj_scanpos;
37318 if (jj_3R_277()) {
37319 jj_scanpos = xsp;
37320 if (jj_3R_278()) return true;
37321 }
37322 return false;
37323 }
37324
37325 private boolean jj_3R_623() {
37326 if (jj_scan_token(6)) return true;
37327 if (jj_3R_124()) return true;
37328 return false;
37329 }
37330
37331 private boolean jj_3R_475() {
37332 if (jj_scan_token(DBTIMEZONE)) return true;
37333 return false;
37334 }
37335
37336 private boolean jj_3_24() {
37337 Token xsp;
37338 xsp = jj_scanpos;
37339 if (jj_scan_token(207)) {
37340 jj_scanpos = xsp;
37341 if (jj_3R_125()) return true;
37342 }
37343 xsp = jj_scanpos;
37344 if (jj_3_23()) jj_scanpos = xsp;
37345 return false;
37346 }
37347
37348 private boolean jj_3R_559() {
37349 if (jj_3R_235()) return true;
37350 return false;
37351 }
37352
37353 private boolean jj_3R_462() {
37354 if (jj_3R_350()) return true;
37355 return false;
37356 }
37357
37358 private boolean jj_3R_297() {
37359 if (jj_scan_token(TIME)) return true;
37360 if (jj_scan_token(ZONE)) return true;
37361 Token xsp;
37362 xsp = jj_scanpos;
37363 if (jj_3R_475()) {
37364 jj_scanpos = xsp;
37365 if (jj_3R_476()) {
37366 jj_scanpos = xsp;
37367 if (jj_3R_477()) {
37368 jj_scanpos = xsp;
37369 if (jj_3R_478()) return true;
37370 }
37371 }
37372 }
37373 return false;
37374 }
37375
37376 private boolean jj_3R_600() {
37377 if (jj_scan_token(6)) return true;
37378 if (jj_3R_124()) return true;
37379 Token xsp;
37380 xsp = jj_scanpos;
37381 if (jj_3R_624()) jj_scanpos = xsp;
37382 return false;
37383 }
37384
37385 private boolean jj_3R_486() {
37386 if (jj_scan_token(3)) return true;
37387 if (jj_3R_124()) return true;
37388 return false;
37389 }
37390
37391 private boolean jj_3R_470() {
37392 if (jj_3R_146()) return true;
37393 return false;
37394 }
37395
37396 private boolean jj_3R_225() {
37397 if (jj_3R_298()) return true;
37398 return false;
37399 }
37400
37401 private boolean jj_3R_296() {
37402 if (jj_scan_token(LOCAL)) return true;
37403 return false;
37404 }
37405
37406 private boolean jj_3R_469() {
37407 if (jj_3R_118()) return true;
37408 return false;
37409 }
37410
37411 private boolean jj_3R_237() {
37412 if (jj_3R_282()) return true;
37413 return false;
37414 }
37415
37416 private boolean jj_3R_425() {
37417 Token xsp;
37418 xsp = jj_scanpos;
37419 if (jj_3R_469()) {
37420 jj_scanpos = xsp;
37421 if (jj_3R_470()) return true;
37422 }
37423 return false;
37424 }
37425
37426 private boolean jj_3R_597() {
37427 if (jj_scan_token(9)) return true;
37428 if (jj_scan_token(10)) return true;
37429 return false;
37430 }
37431
37432 private boolean jj_3R_560() {
37433 Token xsp;
37434 xsp = jj_scanpos;
37435 if (jj_3R_597()) {
37436 jj_scanpos = xsp;
37437 if (jj_scan_token(92)) return true;
37438 }
37439 if (jj_3R_233()) return true;
37440 return false;
37441 }
37442
37443 private boolean jj_3_25() {
37444 Token xsp;
37445 xsp = jj_scanpos;
37446 if (jj_3_24()) {
37447 jj_scanpos = xsp;
37448 if (jj_scan_token(137)) return true;
37449 }
37450 return false;
37451 }
37452
37453 private boolean jj_3R_599() {
37454 if (jj_scan_token(3)) return true;
37455 if (jj_3R_124()) return true;
37456 return false;
37457 }
37458
37459 private boolean jj_3R_224() {
37460 if (jj_scan_token(AT)) return true;
37461 Token xsp;
37462 xsp = jj_scanpos;
37463 if (jj_3R_296()) {
37464 jj_scanpos = xsp;
37465 if (jj_3R_297()) return true;
37466 }
37467 return false;
37468 }
37469
37470 private boolean jj_3R_516() {
37471 if (jj_3R_124()) return true;
37472 return false;
37473 }
37474
37475 private boolean jj_3R_461() {
37476 if (jj_3R_173()) return true;
37477 return false;
37478 }
37479
37480 private boolean jj_3R_460() {
37481 if (jj_3R_422()) return true;
37482 return false;
37483 }
37484
37485 private boolean jj_3R_387() {
37486 if (jj_scan_token(USING)) return true;
37487 if (jj_3R_124()) return true;
37488 Token xsp;
37489 xsp = jj_scanpos;
37490 if (jj_3R_486()) jj_scanpos = xsp;
37491 return false;
37492 }
37493
37494 private boolean jj_3R_223() {
37495 if (jj_scan_token(2)) return true;
37496 if (jj_3R_120()) return true;
37497 return false;
37498 }
37499
37500 private boolean jj_3R_142() {
37501 Token xsp;
37502 xsp = jj_scanpos;
37503 if (jj_scan_token(420)) {
37504 jj_scanpos = xsp;
37505 if (jj_scan_token(428)) {
37506 jj_scanpos = xsp;
37507 if (jj_3R_237()) {
37508 jj_scanpos = xsp;
37509 if (jj_scan_token(60)) {
37510 jj_scanpos = xsp;
37511 if (jj_scan_token(171)) {
37512 jj_scanpos = xsp;
37513 if (jj_scan_token(201)) {
37514 jj_scanpos = xsp;
37515 if (jj_scan_token(222)) {
37516 jj_scanpos = xsp;
37517 if (jj_scan_token(227)) {
37518 jj_scanpos = xsp;
37519 if (jj_scan_token(35)) {
37520 jj_scanpos = xsp;
37521 if (jj_scan_token(308)) {
37522 jj_scanpos = xsp;
37523 if (jj_scan_token(258)) {
37524 jj_scanpos = xsp;
37525 if (jj_scan_token(259)) {
37526 jj_scanpos = xsp;
37527 if (jj_scan_token(260)) {
37528 jj_scanpos = xsp;
37529 if (jj_scan_token(269)) {
37530 jj_scanpos = xsp;
37531 if (jj_scan_token(284)) {
37532 jj_scanpos = xsp;
37533 if (jj_scan_token(161)) {
37534 jj_scanpos = xsp;
37535 if (jj_scan_token(303)) {
37536 jj_scanpos = xsp;
37537 if (jj_scan_token(50)) return true;
37538 }
37539 }
37540 }
37541 }
37542 }
37543 }
37544 }
37545 }
37546 }
37547 }
37548 }
37549 }
37550 }
37551 }
37552 }
37553 }
37554 }
37555 return false;
37556 }
37557
37558 private boolean jj_3R_630() {
37559 if (jj_scan_token(NOT)) return true;
37560 return false;
37561 }
37562
37563 private boolean jj_3R_474() {
37564 if (jj_3R_124()) return true;
37565 Token xsp;
37566 xsp = jj_scanpos;
37567 if (jj_3_25()) jj_scanpos = xsp;
37568 xsp = jj_scanpos;
37569 if (jj_scan_token(8)) {
37570 jj_scanpos = xsp;
37571 if (jj_3R_559()) return true;
37572 }
37573 xsp = jj_scanpos;
37574 if (jj_3R_560()) jj_scanpos = xsp;
37575 return false;
37576 }
37577
37578 private boolean jj_3R_222() {
37579 if (jj_scan_token(3)) return true;
37580 if (jj_3R_120()) return true;
37581 return false;
37582 }
37583
37584 private boolean jj_3R_135() {
37585 Token xsp;
37586 xsp = jj_scanpos;
37587 if (jj_3R_222()) {
37588 jj_scanpos = xsp;
37589 if (jj_3R_223()) {
37590 jj_scanpos = xsp;
37591 if (jj_3R_224()) {
37592 jj_scanpos = xsp;
37593 if (jj_3R_225()) return true;
37594 }
37595 }
37596 }
37597 return false;
37598 }
37599
37600 private boolean jj_3R_515() {
37601 if (jj_scan_token(3)) return true;
37602 if (jj_3R_124()) return true;
37603 return false;
37604 }
37605
37606 private boolean jj_3R_331() {
37607 if (jj_3R_191()) return true;
37608 if (jj_scan_token(BEGIN)) return true;
37609 Token xsp;
37610 xsp = jj_scanpos;
37611 if (jj_3R_460()) jj_scanpos = xsp;
37612 while (true) {
37613 xsp = jj_scanpos;
37614 if (jj_3R_461()) { jj_scanpos = xsp; break; }
37615 }
37616 xsp = jj_scanpos;
37617 if (jj_3R_462()) jj_scanpos = xsp;
37618 if (jj_scan_token(END)) return true;
37619 xsp = jj_scanpos;
37620 if (jj_3R_463()) jj_scanpos = xsp;
37621 return false;
37622 }
37623
37624 private boolean jj_3_22() {
37625 if (jj_3R_124()) return true;
37626 if (jj_scan_token(3)) return true;
37627 return false;
37628 }
37629
37630 private boolean jj_3_21() {
37631 if (jj_3R_123()) return true;
37632 return false;
37633 }
37634
37635 private boolean jj_3_56() {
37636 Token xsp;
37637 if (jj_scan_token(5)) return true;
37638 while (true) {
37639 xsp = jj_scanpos;
37640 if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
37641 }
37642 if (jj_scan_token(WITH)) return true;
37643 return false;
37644 }
37645
37646 private boolean jj_3R_154() {
37647 Token xsp;
37648 xsp = jj_scanpos;
37649 if (jj_3_22()) jj_scanpos = xsp;
37650 if (jj_3R_124()) return true;
37651 return false;
37652 }
37653
37654 private boolean jj_3_55() {
37655 if (jj_scan_token(WITH)) return true;
37656 return false;
37657 }
37658
37659 private boolean jj_3_54() {
37660 Token xsp;
37661 if (jj_scan_token(5)) return true;
37662 while (true) {
37663 xsp = jj_scanpos;
37664 if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
37665 }
37666 if (jj_scan_token(SELECT)) return true;
37667 return false;
37668 }
37669
37670 private boolean jj_3_53() {
37671 if (jj_scan_token(SELECT)) return true;
37672 return false;
37673 }
37674
37675 private boolean jj_3R_295() {
37676 if (jj_scan_token(6)) return true;
37677 if (jj_3R_233()) return true;
37678 return false;
37679 }
37680
37681 private boolean jj_3R_389() {
37682 if (jj_scan_token(RELIES_ON)) return true;
37683 if (jj_scan_token(5)) return true;
37684 if (jj_3R_124()) return true;
37685 Token xsp;
37686 xsp = jj_scanpos;
37687 if (jj_3R_599()) jj_scanpos = xsp;
37688 while (true) {
37689 xsp = jj_scanpos;
37690 if (jj_3R_600()) { jj_scanpos = xsp; break; }
37691 }
37692 if (jj_scan_token(7)) return true;
37693 return false;
37694 }
37695
37696 private boolean jj_3R_386() {
37697 if (jj_3R_428()) return true;
37698 return false;
37699 }
37700
37701 private boolean jj_3_52() {
37702 if (jj_3R_139()) return true;
37703 return false;
37704 }
37705
37706 private boolean jj_3_51() {
37707 if (jj_3R_138()) return true;
37708 return false;
37709 }
37710
37711 private boolean jj_3R_221() {
37712 if (jj_scan_token(5)) return true;
37713 if (jj_3R_233()) return true;
37714 Token xsp;
37715 while (true) {
37716 xsp = jj_scanpos;
37717 if (jj_3R_295()) { jj_scanpos = xsp; break; }
37718 }
37719 if (jj_scan_token(7)) return true;
37720 return false;
37721 }
37722
37723 private boolean jj_3_50() {
37724 if (jj_3R_137()) return true;
37725 return false;
37726 }
37727
37728 private boolean jj_3_49() {
37729 if (jj_3R_136()) return true;
37730 return false;
37731 }
37732
37733 private boolean jj_3R_430() {
37734 Token xsp;
37735 xsp = jj_scanpos;
37736 if (jj_scan_token(204)) {
37737 jj_scanpos = xsp;
37738 if (jj_scan_token(71)) return true;
37739 }
37740 xsp = jj_scanpos;
37741 if (jj_3R_516()) jj_scanpos = xsp;
37742 if (jj_scan_token(BY)) return true;
37743 if (jj_scan_token(5)) return true;
37744 if (jj_3R_124()) return true;
37745 while (true) {
37746 xsp = jj_scanpos;
37747 if (jj_3R_623()) { jj_scanpos = xsp; break; }
37748 }
37749 if (jj_scan_token(7)) return true;
37750 return false;
37751 }
37752
37753 private boolean jj_3R_220() {
37754 if (jj_scan_token(5)) return true;
37755 if (jj_3R_179()) return true;
37756 if (jj_scan_token(7)) return true;
37757 return false;
37758 }
37759
37760 private boolean jj_3R_281() {
37761 Token xsp;
37762 xsp = jj_scanpos;
37763 if (jj_scan_token(152)) {
37764 jj_scanpos = xsp;
37765 if (jj_scan_token(51)) return true;
37766 }
37767 xsp = jj_scanpos;
37768 if (jj_3_21()) {
37769 jj_scanpos = xsp;
37770 if (jj_3R_331()) return true;
37771 }
37772 return false;
37773 }
37774
37775 private boolean jj_3R_219() {
37776 if (jj_scan_token(WITH)) return true;
37777 if (jj_3R_179()) return true;
37778 return false;
37779 }
37780
37781 private boolean jj_3R_429() {
37782 if (jj_scan_token(USING)) return true;
37783 if (jj_3R_124()) return true;
37784 Token xsp;
37785 xsp = jj_scanpos;
37786 if (jj_3R_515()) jj_scanpos = xsp;
37787 return false;
37788 }
37789
37790 private boolean jj_3R_388() {
37791 Token xsp;
37792 xsp = jj_scanpos;
37793 if (jj_3R_429()) {
37794 jj_scanpos = xsp;
37795 if (jj_3R_430()) return true;
37796 }
37797 return false;
37798 }
37799
37800 private boolean jj_3R_218() {
37801 if (jj_scan_token(5)) return true;
37802 if (jj_3R_179()) return true;
37803 if (jj_scan_token(7)) return true;
37804 return false;
37805 }
37806
37807 private boolean jj_3R_217() {
37808 if (jj_scan_token(SELECT)) return true;
37809 if (jj_3R_179()) return true;
37810 return false;
37811 }
37812
37813 private boolean jj_3R_216() {
37814 if (jj_3R_294()) return true;
37815 return false;
37816 }
37817
37818 private boolean jj_3R_215() {
37819 if (jj_3R_139()) return true;
37820 return false;
37821 }
37822
37823 private boolean jj_3R_276() {
37824 Token xsp;
37825 xsp = jj_scanpos;
37826 if (jj_scan_token(100)) {
37827 jj_scanpos = xsp;
37828 if (jj_scan_token(182)) return true;
37829 }
37830 return false;
37831 }
37832
37833 private boolean jj_3R_214() {
37834 if (jj_3R_138()) return true;
37835 return false;
37836 }
37837
37838 private boolean jj_3R_213() {
37839 if (jj_3R_137()) return true;
37840 return false;
37841 }
37842
37843 private boolean jj_3R_212() {
37844 if (jj_3R_136()) return true;
37845 return false;
37846 }
37847
37848 private boolean jj_3R_211() {
37849 if (jj_3R_293()) return true;
37850 return false;
37851 }
37852
37853 private boolean jj_3R_280() {
37854 if (jj_scan_token(AGGREGATE)) return true;
37855 if (jj_scan_token(USING)) return true;
37856 if (jj_3R_124()) return true;
37857 return false;
37858 }
37859
37860 private boolean jj_3R_330() {
37861 if (jj_scan_token(RESULT_CACHE)) return true;
37862 Token xsp;
37863 xsp = jj_scanpos;
37864 if (jj_3R_389()) jj_scanpos = xsp;
37865 return false;
37866 }
37867
37868 private boolean jj_3R_134() {
37869 Token xsp;
37870 xsp = jj_scanpos;
37871 if (jj_3R_211()) {
37872 jj_scanpos = xsp;
37873 if (jj_3R_212()) {
37874 jj_scanpos = xsp;
37875 if (jj_3R_213()) {
37876 jj_scanpos = xsp;
37877 if (jj_3R_214()) {
37878 jj_scanpos = xsp;
37879 if (jj_3R_215()) {
37880 jj_scanpos = xsp;
37881 if (jj_3R_216()) {
37882 jj_scanpos = xsp;
37883 if (jj_3R_217()) {
37884 jj_scanpos = xsp;
37885 if (jj_3R_218()) {
37886 jj_scanpos = xsp;
37887 if (jj_3R_219()) {
37888 jj_scanpos = xsp;
37889 if (jj_3R_220()) {
37890 jj_scanpos = xsp;
37891 if (jj_3R_221()) return true;
37892 }
37893 }
37894 }
37895 }
37896 }
37897 }
37898 }
37899 }
37900 }
37901 }
37902 return false;
37903 }
37904
37905 private boolean jj_3_48() {
37906 if (jj_3R_135()) return true;
37907 return false;
37908 }
37909
37910 private boolean jj_3_47() {
37911 if (jj_scan_token(NEW)) return true;
37912 if (jj_3R_134()) return true;
37913 return false;
37914 }
37915
37916 private boolean jj_3R_292() {
37917 if (jj_3R_134()) return true;
37918 return false;
37919 }
37920
37921 private boolean jj_3R_329() {
37922 if (jj_scan_token(PIPELINED)) return true;
37923 Token xsp;
37924 xsp = jj_scanpos;
37925 if (jj_3R_388()) jj_scanpos = xsp;
37926 return false;
37927 }
37928
37929 private boolean jj_3R_328() {
37930 if (jj_scan_token(PARALLEL_ENABLE)) return true;
37931 Token xsp;
37932 xsp = jj_scanpos;
37933 if (jj_3R_386()) jj_scanpos = xsp;
37934 xsp = jj_scanpos;
37935 if (jj_3R_387()) jj_scanpos = xsp;
37936 return false;
37937 }
37938
37939 private boolean jj_3R_327() {
37940 if (jj_3R_238()) return true;
37941 return false;
37942 }
37943
37944 private boolean jj_3R_279() {
37945 Token xsp;
37946 xsp = jj_scanpos;
37947 if (jj_3R_326()) {
37948 jj_scanpos = xsp;
37949 if (jj_scan_token(95)) {
37950 jj_scanpos = xsp;
37951 if (jj_3R_327()) {
37952 jj_scanpos = xsp;
37953 if (jj_3R_328()) {
37954 jj_scanpos = xsp;
37955 if (jj_3R_329()) {
37956 jj_scanpos = xsp;
37957 if (jj_3R_330()) return true;
37958 }
37959 }
37960 }
37961 }
37962 }
37963 return false;
37964 }
37965
37966 private boolean jj_3R_326() {
37967 if (jj_scan_token(AUTHID)) return true;
37968 Token xsp;
37969 xsp = jj_scanpos;
37970 if (jj_scan_token(37)) {
37971 jj_scanpos = xsp;
37972 if (jj_scan_token(36)) return true;
37973 }
37974 return false;
37975 }
37976
37977 private boolean jj_3R_195() {
37978 Token xsp;
37979 while (true) {
37980 xsp = jj_scanpos;
37981 if (jj_3R_279()) { jj_scanpos = xsp; break; }
37982 }
37983 xsp = jj_scanpos;
37984 if (jj_3R_280()) jj_scanpos = xsp;
37985 xsp = jj_scanpos;
37986 if (jj_3R_281()) jj_scanpos = xsp;
37987 if (jj_scan_token(4)) return true;
37988 return false;
37989 }
37990
37991 private boolean jj_3R_275() {
37992 if (jj_scan_token(OR)) return true;
37993 if (jj_scan_token(REPLACE)) return true;
37994 return false;
37995 }
37996
37997 private boolean jj_3R_291() {
37998 if (jj_scan_token(NEW)) return true;
37999 if (jj_3R_134()) return true;
38000 return false;
38001 }
38002
38003 private boolean jj_3R_631() {
38004 if (jj_scan_token(6)) return true;
38005 Token xsp;
38006 xsp = jj_scanpos;
38007 if (jj_scan_token(198)) jj_scanpos = xsp;
38008 if (jj_3R_294()) return true;
38009 return false;
38010 }
38011
38012 private boolean jj_3R_210() {
38013 Token xsp;
38014 xsp = jj_scanpos;
38015 if (jj_3R_291()) {
38016 jj_scanpos = xsp;
38017 if (jj_3R_292()) return true;
38018 }
38019 while (true) {
38020 xsp = jj_scanpos;
38021 if (jj_3_48()) { jj_scanpos = xsp; break; }
38022 }
38023 return false;
38024 }
38025
38026 private boolean jj_3R_194() {
38027 if (jj_3R_248()) return true;
38028 return false;
38029 }
38030
38031 private boolean jj_3R_209() {
38032 if (jj_scan_token(NEW_DOT)) return true;
38033 if (jj_3R_120()) return true;
38034 return false;
38035 }
38036
38037 private boolean jj_3R_192() {
38038 if (jj_scan_token(CREATE)) return true;
38039 Token xsp;
38040 xsp = jj_scanpos;
38041 if (jj_3R_275()) jj_scanpos = xsp;
38042 xsp = jj_scanpos;
38043 if (jj_3R_276()) jj_scanpos = xsp;
38044 return false;
38045 }
38046
38047 private boolean jj_3R_133() {
38048 Token xsp;
38049 xsp = jj_scanpos;
38050 if (jj_3R_209()) {
38051 jj_scanpos = xsp;
38052 if (jj_3R_210()) return true;
38053 }
38054 return false;
38055 }
38056
38057 private boolean jj_3R_118() {
38058 Token xsp;
38059 xsp = jj_scanpos;
38060 if (jj_3R_192()) jj_scanpos = xsp;
38061 if (jj_3R_193()) return true;
38062 xsp = jj_scanpos;
38063 if (jj_3R_194()) {
38064 jj_scanpos = xsp;
38065 if (jj_3R_195()) return true;
38066 }
38067 return false;
38068 }
38069
38070 private boolean jj_3_46() {
38071 if (jj_scan_token(IDENTIFIER)) return true;
38072 if (jj_scan_token(IS)) return true;
38073 return false;
38074 }
38075
38076 private boolean jj_3R_626() {
38077 if (jj_3R_133()) return true;
38078 return false;
38079 }
38080
38081 private boolean jj_3R_534() {
38082 if (jj_scan_token(CC_ERROR)) return true;
38083 if (jj_3R_233()) return true;
38084 if (jj_scan_token(CC_END)) return true;
38085 return false;
38086 }
38087
38088 private boolean jj_3R_625() {
38089 if (jj_3R_294()) return true;
38090 if (jj_scan_token(IS)) return true;
38091 Token xsp;
38092 xsp = jj_scanpos;
38093 if (jj_3R_630()) jj_scanpos = xsp;
38094 if (jj_scan_token(OF)) return true;
38095 xsp = jj_scanpos;
38096 if (jj_scan_token(284)) jj_scanpos = xsp;
38097 if (jj_scan_token(5)) return true;
38098 xsp = jj_scanpos;
38099 if (jj_scan_token(198)) jj_scanpos = xsp;
38100 if (jj_3R_294()) return true;
38101 while (true) {
38102 xsp = jj_scanpos;
38103 if (jj_3R_631()) { jj_scanpos = xsp; break; }
38104 }
38105 if (jj_scan_token(7)) return true;
38106 return false;
38107 }
38108
38109 private boolean jj_3R_533() {
38110 if (jj_3R_322()) return true;
38111 return false;
38112 }
38113
38114 private boolean jj_3R_505() {
38115 Token xsp;
38116 xsp = jj_scanpos;
38117 if (jj_3R_533()) {
38118 jj_scanpos = xsp;
38119 if (jj_3R_534()) return true;
38120 }
38121 return false;
38122 }
38123
38124 private boolean jj_3R_614() {
38125 Token xsp;
38126 xsp = jj_scanpos;
38127 if (jj_3R_625()) {
38128 jj_scanpos = xsp;
38129 if (jj_3R_626()) return true;
38130 }
38131 return false;
38132 }
38133
38134 private boolean jj_3R_473() {
38135 if (jj_scan_token(CC_ELSE)) return true;
38136 Token xsp;
38137 while (true) {
38138 xsp = jj_scanpos;
38139 if (jj_3R_505()) { jj_scanpos = xsp; break; }
38140 }
38141 return false;
38142 }
38143
38144 private boolean jj_3R_532() {
38145 if (jj_scan_token(CC_ERROR)) return true;
38146 if (jj_3R_233()) return true;
38147 if (jj_scan_token(CC_END)) return true;
38148 return false;
38149 }
38150
38151 private boolean jj_3R_531() {
38152 if (jj_3R_322()) return true;
38153 return false;
38154 }
38155
38156 private boolean jj_3R_504() {
38157 Token xsp;
38158 xsp = jj_scanpos;
38159 if (jj_3R_531()) {
38160 jj_scanpos = xsp;
38161 if (jj_3R_532()) return true;
38162 }
38163 return false;
38164 }
38165
38166 private boolean jj_3R_589() {
38167 if (jj_3R_614()) return true;
38168 return false;
38169 }
38170
38171 private boolean jj_3R_472() {
38172 if (jj_scan_token(CC_ELSIF)) return true;
38173 if (jj_3R_343()) return true;
38174 if (jj_scan_token(CC_THEN)) return true;
38175 Token xsp;
38176 while (true) {
38177 xsp = jj_scanpos;
38178 if (jj_3R_504()) { jj_scanpos = xsp; break; }
38179 }
38180 return false;
38181 }
38182
38183 private boolean jj_3R_503() {
38184 if (jj_scan_token(CC_ERROR)) return true;
38185 if (jj_3R_233()) return true;
38186 if (jj_scan_token(CC_END)) return true;
38187 return false;
38188 }
38189
38190 private boolean jj_3R_253() {
38191 if (jj_3R_124()) return true;
38192 return false;
38193 }
38194
38195 private boolean jj_3R_588() {
38196 if (jj_scan_token(NOT)) return true;
38197 if (jj_3R_483()) return true;
38198 return false;
38199 }
38200
38201 private boolean jj_3R_502() {
38202 if (jj_3R_322()) return true;
38203 return false;
38204 }
38205
38206 private boolean jj_3R_471() {
38207 Token xsp;
38208 xsp = jj_scanpos;
38209 if (jj_3R_502()) {
38210 jj_scanpos = xsp;
38211 if (jj_3R_503()) return true;
38212 }
38213 return false;
38214 }
38215
38216 private boolean jj_3R_544() {
38217 Token xsp;
38218 xsp = jj_scanpos;
38219 if (jj_3R_588()) {
38220 jj_scanpos = xsp;
38221 if (jj_3R_589()) return true;
38222 }
38223 return false;
38224 }
38225
38226 private boolean jj_3R_426() {
38227 if (jj_scan_token(CC_IF)) return true;
38228 if (jj_3R_343()) return true;
38229 if (jj_scan_token(CC_THEN)) return true;
38230 Token xsp;
38231 while (true) {
38232 xsp = jj_scanpos;
38233 if (jj_3R_471()) { jj_scanpos = xsp; break; }
38234 }
38235 while (true) {
38236 xsp = jj_scanpos;
38237 if (jj_3R_472()) { jj_scanpos = xsp; break; }
38238 }
38239 while (true) {
38240 xsp = jj_scanpos;
38241 if (jj_3R_473()) { jj_scanpos = xsp; break; }
38242 }
38243 if (jj_scan_token(CC_END)) return true;
38244 return false;
38245 }
38246
38247 private boolean jj_3R_513() {
38248 if (jj_3R_544()) return true;
38249 return false;
38250 }
38251
38252 private boolean jj_3R_274() {
38253 if (jj_3R_322()) return true;
38254 return false;
38255 }
38256
38257 private boolean jj_3R_543() {
38258 if (jj_scan_token(17)) return true;
38259 return false;
38260 }
38261
38262 private boolean jj_3R_542() {
38263 if (jj_scan_token(16)) return true;
38264 return false;
38265 }
38266
38267 private boolean jj_3R_512() {
38268 Token xsp;
38269 xsp = jj_scanpos;
38270 if (jj_3R_542()) {
38271 jj_scanpos = xsp;
38272 if (jj_3R_543()) return true;
38273 }
38274 if (jj_3R_483()) return true;
38275 return false;
38276 }
38277
38278 private boolean jj_3R_483() {
38279 Token xsp;
38280 xsp = jj_scanpos;
38281 if (jj_3R_512()) {
38282 jj_scanpos = xsp;
38283 if (jj_3R_513()) return true;
38284 }
38285 return false;
38286 }
38287
38288 private boolean jj_3R_384() {
38289 if (jj_3R_426()) return true;
38290 return false;
38291 }
38292
38293 private boolean jj_3R_191() {
38294 Token xsp;
38295 while (true) {
38296 xsp = jj_scanpos;
38297 if (jj_3R_274()) { jj_scanpos = xsp; break; }
38298 }
38299 return false;
38300 }
38301
38302 private boolean jj_3R_383() {
38303 if (jj_3R_425()) return true;
38304 return false;
38305 }
38306
38307 private boolean jj_3_18() {
38308 Token xsp;
38309 xsp = jj_scanpos;
38310 if (jj_scan_token(125)) {
38311 jj_scanpos = xsp;
38312 if (jj_scan_token(223)) return true;
38313 }
38314 if (jj_3R_120()) return true;
38315 return false;
38316 }
38317
38318 private boolean jj_3_17() {
38319 Token xsp;
38320 xsp = jj_scanpos;
38321 if (jj_scan_token(284)) {
38322 jj_scanpos = xsp;
38323 if (jj_scan_token(264)) return true;
38324 }
38325 if (jj_3R_120()) return true;
38326 xsp = jj_scanpos;
38327 if (jj_scan_token(152)) {
38328 jj_scanpos = xsp;
38329 if (jj_scan_token(51)) return true;
38330 }
38331 return false;
38332 }
38333
38334 private boolean jj_3R_382() {
38335 if (jj_3R_424()) return true;
38336 return false;
38337 }
38338
38339 private boolean jj_3R_381() {
38340 if (jj_3R_423()) return true;
38341 return false;
38342 }
38343
38344 private boolean jj_3R_607() {
38345 if (jj_scan_token(MOD)) return true;
38346 return false;
38347 }
38348
38349 private boolean jj_3_20() {
38350 if (jj_3R_122()) return true;
38351 return false;
38352 }
38353
38354 private boolean jj_3R_606() {
38355 if (jj_scan_token(1)) return true;
38356 return false;
38357 }
38358
38359 private boolean jj_3R_306() {
38360 if (jj_3R_350()) return true;
38361 return false;
38362 }
38363
38364 private boolean jj_3R_605() {
38365 if (jj_scan_token(20)) return true;
38366 return false;
38367 }
38368
38369 private boolean jj_3_19() {
38370 if (jj_3R_121()) return true;
38371 return false;
38372 }
38373
38374 private boolean jj_3R_604() {
38375 if (jj_scan_token(19)) return true;
38376 return false;
38377 }
38378
38379 private boolean jj_3R_380() {
38380 if (jj_3R_118()) return true;
38381 return false;
38382 }
38383
38384 private boolean jj_3R_569() {
38385 Token xsp;
38386 xsp = jj_scanpos;
38387 if (jj_3R_604()) {
38388 jj_scanpos = xsp;
38389 if (jj_3R_605()) {
38390 jj_scanpos = xsp;
38391 if (jj_3R_606()) {
38392 jj_scanpos = xsp;
38393 if (jj_3R_607()) return true;
38394 }
38395 }
38396 }
38397 if (jj_3R_483()) return true;
38398 return false;
38399 }
38400
38401 private boolean jj_3R_379() {
38402 if (jj_3R_152()) return true;
38403 return false;
38404 }
38405
38406 private boolean jj_3_16() {
38407 if (jj_3R_119()) return true;
38408 return false;
38409 }
38410
38411 private boolean jj_3R_378() {
38412 if (jj_3R_422()) return true;
38413 return false;
38414 }
38415
38416 private boolean jj_3R_536() {
38417 if (jj_3R_483()) return true;
38418 Token xsp;
38419 while (true) {
38420 xsp = jj_scanpos;
38421 if (jj_3R_569()) { jj_scanpos = xsp; break; }
38422 }
38423 return false;
38424 }
38425
38426 private boolean jj_3_15() {
38427 if (jj_3R_118()) return true;
38428 return false;
38429 }
38430
38431 private boolean jj_3R_251() {
38432 Token xsp;
38433 xsp = jj_scanpos;
38434 if (jj_scan_token(100)) {
38435 jj_scanpos = xsp;
38436 if (jj_scan_token(182)) return true;
38437 }
38438 return false;
38439 }
38440
38441 private boolean jj_3R_305() {
38442 if (jj_3R_173()) return true;
38443 return false;
38444 }
38445
38446 private boolean jj_3R_299() {
38447 if (jj_scan_token(18)) return true;
38448 if (jj_3R_133()) return true;
38449 return false;
38450 }
38451
38452 private boolean jj_3R_322() {
38453 Token xsp;
38454 xsp = jj_scanpos;
38455 if (jj_3R_378()) {
38456 jj_scanpos = xsp;
38457 if (jj_3_16()) {
38458 jj_scanpos = xsp;
38459 if (jj_3R_379()) {
38460 jj_scanpos = xsp;
38461 if (jj_3R_380()) {
38462 jj_scanpos = xsp;
38463 if (jj_3_19()) {
38464 jj_scanpos = xsp;
38465 if (jj_3_20()) {
38466 jj_scanpos = xsp;
38467 if (jj_3R_381()) {
38468 jj_scanpos = xsp;
38469 if (jj_3R_382()) {
38470 jj_scanpos = xsp;
38471 if (jj_3R_383()) {
38472 jj_scanpos = xsp;
38473 if (jj_3R_384()) return true;
38474 }
38475 }
38476 }
38477 }
38478 }
38479 }
38480 }
38481 }
38482 }
38483 return false;
38484 }
38485
38486 private boolean jj_3R_252() {
38487 if (jj_scan_token(BEGIN)) return true;
38488 Token xsp;
38489 while (true) {
38490 xsp = jj_scanpos;
38491 if (jj_3R_305()) { jj_scanpos = xsp; break; }
38492 }
38493 xsp = jj_scanpos;
38494 if (jj_3R_306()) jj_scanpos = xsp;
38495 return false;
38496 }
38497
38498 private boolean jj_3R_229() {
38499 if (jj_3R_133()) return true;
38500 Token xsp;
38501 while (true) {
38502 xsp = jj_scanpos;
38503 if (jj_3R_299()) { jj_scanpos = xsp; break; }
38504 }
38505 return false;
38506 }
38507
38508 private boolean jj_3R_250() {
38509 if (jj_scan_token(OR)) return true;
38510 if (jj_scan_token(REPLACE)) return true;
38511 return false;
38512 }
38513
38514 private boolean jj_3R_160() {
38515 Token xsp;
38516 xsp = jj_scanpos;
38517 if (jj_scan_token(152)) {
38518 jj_scanpos = xsp;
38519 if (jj_scan_token(51)) return true;
38520 }
38521 if (jj_3R_191()) return true;
38522 xsp = jj_scanpos;
38523 if (jj_3R_252()) jj_scanpos = xsp;
38524 if (jj_scan_token(END)) return true;
38525 xsp = jj_scanpos;
38526 if (jj_3R_253()) jj_scanpos = xsp;
38527 if (jj_scan_token(4)) return true;
38528 return false;
38529 }
38530
38531 private boolean jj_3R_572() {
38532 if (jj_scan_token(18)) return true;
38533 return false;
38534 }
38535
38536 private boolean jj_3R_571() {
38537 if (jj_scan_token(17)) return true;
38538 return false;
38539 }
38540
38541 private boolean jj_3R_159() {
38542 if (jj_3R_248()) return true;
38543 return false;
38544 }
38545
38546 private boolean jj_3R_570() {
38547 if (jj_scan_token(16)) return true;
38548 return false;
38549 }
38550
38551 private boolean jj_3R_270() {
38552 if (jj_3R_190()) return true;
38553 return false;
38554 }
38555
38556 private boolean jj_3R_537() {
38557 Token xsp;
38558 xsp = jj_scanpos;
38559 if (jj_3R_570()) {
38560 jj_scanpos = xsp;
38561 if (jj_3R_571()) {
38562 jj_scanpos = xsp;
38563 if (jj_3R_572()) return true;
38564 }
38565 }
38566 if (jj_3R_536()) return true;
38567 return false;
38568 }
38569
38570 private boolean jj_3R_158() {
38571 if (jj_scan_token(CREATE)) return true;
38572 Token xsp;
38573 xsp = jj_scanpos;
38574 if (jj_3R_250()) jj_scanpos = xsp;
38575 xsp = jj_scanpos;
38576 if (jj_3R_251()) jj_scanpos = xsp;
38577 return false;
38578 }
38579
38580 private boolean jj_3R_245() {
38581 Token xsp;
38582 xsp = jj_scanpos;
38583 if (jj_scan_token(100)) {
38584 jj_scanpos = xsp;
38585 if (jj_scan_token(182)) return true;
38586 }
38587 return false;
38588 }
38589
38590 private boolean jj_3R_249() {
38591 if (jj_3R_124()) return true;
38592 return false;
38593 }
38594
38595 private boolean jj_3R_507() {
38596 if (jj_3R_536()) return true;
38597 Token xsp;
38598 while (true) {
38599 xsp = jj_scanpos;
38600 if (jj_3R_537()) { jj_scanpos = xsp; break; }
38601 }
38602 return false;
38603 }
38604
38605 private boolean jj_3R_587() {
38606 if (jj_3R_182()) return true;
38607 return false;
38608 }
38609
38610 private boolean jj_3R_104() {
38611 Token xsp;
38612 xsp = jj_scanpos;
38613 if (jj_3R_158()) jj_scanpos = xsp;
38614 xsp = jj_scanpos;
38615 if (jj_scan_token(209)) {
38616 jj_scanpos = xsp;
38617 if (jj_scan_token(284)) return true;
38618 }
38619 if (jj_scan_token(BODY)) return true;
38620 if (jj_3R_154()) return true;
38621 xsp = jj_scanpos;
38622 if (jj_3R_159()) {
38623 jj_scanpos = xsp;
38624 if (jj_3R_160()) return true;
38625 }
38626 return false;
38627 }
38628
38629 private boolean jj_3R_586() {
38630 if (jj_scan_token(CHARACTER_LITERAL)) return true;
38631 return false;
38632 }
38633
38634 private boolean jj_3R_541() {
38635 if (jj_scan_token(ESCAPE)) return true;
38636 Token xsp;
38637 xsp = jj_scanpos;
38638 if (jj_3R_586()) {
38639 jj_scanpos = xsp;
38640 if (jj_3R_587()) return true;
38641 }
38642 return false;
38643 }
38644
38645 private boolean jj_3R_613() {
38646 if (jj_scan_token(ALL)) return true;
38647 return false;
38648 }
38649
38650 private boolean jj_3R_612() {
38651 if (jj_scan_token(DISTINCT)) return true;
38652 return false;
38653 }
38654
38655 private boolean jj_3R_585() {
38656 Token xsp;
38657 xsp = jj_scanpos;
38658 if (jj_3R_612()) {
38659 jj_scanpos = xsp;
38660 if (jj_3R_613()) return true;
38661 }
38662 return false;
38663 }
38664
38665 private boolean jj_3R_157() {
38666 Token xsp;
38667 xsp = jj_scanpos;
38668 if (jj_scan_token(152)) {
38669 jj_scanpos = xsp;
38670 if (jj_scan_token(51)) return true;
38671 }
38672 if (jj_3R_191()) return true;
38673 if (jj_scan_token(END)) return true;
38674 xsp = jj_scanpos;
38675 if (jj_3R_249()) jj_scanpos = xsp;
38676 if (jj_scan_token(4)) return true;
38677 return false;
38678 }
38679
38680 private boolean jj_3R_584() {
38681 if (jj_scan_token(UNION)) return true;
38682 return false;
38683 }
38684
38685 private boolean jj_3R_583() {
38686 if (jj_scan_token(INTERSECT)) return true;
38687 return false;
38688 }
38689
38690 private boolean jj_3R_582() {
38691 if (jj_scan_token(EXCEPT)) return true;
38692 return false;
38693 }
38694
38695 private boolean jj_3R_156() {
38696 if (jj_3R_248()) return true;
38697 return false;
38698 }
38699
38700 private boolean jj_3R_244() {
38701 if (jj_scan_token(OR)) return true;
38702 if (jj_scan_token(REPLACE)) return true;
38703 return false;
38704 }
38705
38706 private boolean jj_3R_247() {
38707 if (jj_3R_238()) return true;
38708 return false;
38709 }
38710
38711 private boolean jj_3R_611() {
38712 if (jj_scan_token(OF)) return true;
38713 return false;
38714 }
38715
38716 private boolean jj_3R_155() {
38717 Token xsp;
38718 xsp = jj_scanpos;
38719 if (jj_3R_246()) {
38720 jj_scanpos = xsp;
38721 if (jj_3R_247()) return true;
38722 }
38723 return false;
38724 }
38725
38726 private boolean jj_3R_246() {
38727 if (jj_scan_token(AUTHID)) return true;
38728 Token xsp;
38729 xsp = jj_scanpos;
38730 if (jj_scan_token(37)) {
38731 jj_scanpos = xsp;
38732 if (jj_scan_token(36)) return true;
38733 }
38734 return false;
38735 }
38736
38737 private boolean jj_3R_540() {
38738 if (jj_scan_token(MULTISET)) return true;
38739 Token xsp;
38740 xsp = jj_scanpos;
38741 if (jj_3R_582()) {
38742 jj_scanpos = xsp;
38743 if (jj_3R_583()) {
38744 jj_scanpos = xsp;
38745 if (jj_3R_584()) return true;
38746 }
38747 }
38748 xsp = jj_scanpos;
38749 if (jj_3R_585()) jj_scanpos = xsp;
38750 return false;
38751 }
38752
38753 private boolean jj_3R_610() {
38754 if (jj_scan_token(SUBMULTISET)) return true;
38755 return false;
38756 }
38757
38758 private boolean jj_3R_201() {
38759 if (jj_3R_282()) return true;
38760 return false;
38761 }
38762
38763 private boolean jj_3R_609() {
38764 if (jj_scan_token(MEMBER)) return true;
38765 return false;
38766 }
38767
38768 private boolean jj_3R_153() {
38769 if (jj_scan_token(CREATE)) return true;
38770 Token xsp;
38771 xsp = jj_scanpos;
38772 if (jj_3R_244()) jj_scanpos = xsp;
38773 xsp = jj_scanpos;
38774 if (jj_3R_245()) jj_scanpos = xsp;
38775 return false;
38776 }
38777
38778 private boolean jj_3R_103() {
38779 Token xsp;
38780 xsp = jj_scanpos;
38781 if (jj_3R_153()) jj_scanpos = xsp;
38782 if (jj_scan_token(PACKAGE)) return true;
38783 if (jj_3R_154()) return true;
38784 while (true) {
38785 xsp = jj_scanpos;
38786 if (jj_3R_155()) { jj_scanpos = xsp; break; }
38787 }
38788 xsp = jj_scanpos;
38789 if (jj_3R_156()) {
38790 jj_scanpos = xsp;
38791 if (jj_3R_157()) return true;
38792 }
38793 return false;
38794 }
38795
38796 private boolean jj_3R_581() {
38797 Token xsp;
38798 xsp = jj_scanpos;
38799 if (jj_3R_609()) {
38800 jj_scanpos = xsp;
38801 if (jj_3R_610()) return true;
38802 }
38803 xsp = jj_scanpos;
38804 if (jj_3R_611()) jj_scanpos = xsp;
38805 return false;
38806 }
38807
38808 private boolean jj_3R_580() {
38809 if (jj_scan_token(FROM)) return true;
38810 return false;
38811 }
38812
38813 private boolean jj_3R_579() {
38814 if (jj_scan_token(LIKE)) return true;
38815 return false;
38816 }
38817
38818 private boolean jj_3R_578() {
38819 if (jj_scan_token(BETWEEN)) return true;
38820 return false;
38821 }
38822
38823 private boolean jj_3R_117() {
38824 if (jj_scan_token(DECLARE)) return true;
38825 if (jj_3R_191()) return true;
38826 return false;
38827 }
38828
38829 private boolean jj_3R_124() {
38830 Token xsp;
38831 xsp = jj_scanpos;
38832 if (jj_scan_token(420)) {
38833 jj_scanpos = xsp;
38834 if (jj_scan_token(428)) {
38835 jj_scanpos = xsp;
38836 if (jj_3R_201()) {
38837 jj_scanpos = xsp;
38838 if (jj_scan_token(35)) {
38839 jj_scanpos = xsp;
38840 if (jj_scan_token(38)) {
38841 jj_scanpos = xsp;
38842 if (jj_scan_token(39)) {
38843 jj_scanpos = xsp;
38844 if (jj_scan_token(40)) {
38845 jj_scanpos = xsp;
38846 if (jj_scan_token(41)) {
38847 jj_scanpos = xsp;
38848 if (jj_scan_token(46)) {
38849 jj_scanpos = xsp;
38850 if (jj_scan_token(47)) {
38851 jj_scanpos = xsp;
38852 if (jj_scan_token(48)) {
38853 jj_scanpos = xsp;
38854 if (jj_scan_token(49)) {
38855 jj_scanpos = xsp;
38856 if (jj_scan_token(50)) {
38857 jj_scanpos = xsp;
38858 if (jj_scan_token(51)) {
38859 jj_scanpos = xsp;
38860 if (jj_scan_token(52)) {
38861 jj_scanpos = xsp;
38862 if (jj_scan_token(56)) {
38863 jj_scanpos = xsp;
38864 if (jj_scan_token(58)) {
38865 jj_scanpos = xsp;
38866 if (jj_scan_token(59)) {
38867 jj_scanpos = xsp;
38868 if (jj_scan_token(60)) {
38869 jj_scanpos = xsp;
38870 if (jj_scan_token(61)) {
38871 jj_scanpos = xsp;
38872 if (jj_scan_token(63)) {
38873 jj_scanpos = xsp;
38874 if (jj_scan_token(66)) {
38875 jj_scanpos = xsp;
38876 if (jj_scan_token(67)) {
38877 jj_scanpos = xsp;
38878 if (jj_scan_token(68)) {
38879 jj_scanpos = xsp;
38880 if (jj_scan_token(69)) {
38881 jj_scanpos = xsp;
38882 if (jj_scan_token(71)) {
38883 jj_scanpos = xsp;
38884 if (jj_scan_token(77)) {
38885 jj_scanpos = xsp;
38886 if (jj_scan_token(78)) {
38887 jj_scanpos = xsp;
38888 if (jj_scan_token(79)) {
38889 jj_scanpos = xsp;
38890 if (jj_scan_token(83)) {
38891 jj_scanpos = xsp;
38892 if (jj_scan_token(85)) {
38893 jj_scanpos = xsp;
38894 if (jj_scan_token(88)) {
38895 jj_scanpos = xsp;
38896 if (jj_scan_token(90)) {
38897 jj_scanpos = xsp;
38898 if (jj_scan_token(91)) {
38899 jj_scanpos = xsp;
38900 if (jj_scan_token(92)) {
38901 jj_scanpos = xsp;
38902 if (jj_scan_token(93)) {
38903 jj_scanpos = xsp;
38904 if (jj_scan_token(94)) {
38905 jj_scanpos = xsp;
38906 if (jj_scan_token(97)) {
38907 jj_scanpos = xsp;
38908 if (jj_scan_token(98)) {
38909 jj_scanpos = xsp;
38910 if (jj_scan_token(99)) {
38911 jj_scanpos = xsp;
38912 if (jj_scan_token(102)) {
38913 jj_scanpos = xsp;
38914 if (jj_scan_token(103)) {
38915 jj_scanpos = xsp;
38916 if (jj_scan_token(108)) {
38917 jj_scanpos = xsp;
38918 if (jj_scan_token(110)) {
38919 jj_scanpos = xsp;
38920 if (jj_scan_token(111)) {
38921 jj_scanpos = xsp;
38922 if (jj_scan_token(112)) {
38923 jj_scanpos = xsp;
38924 if (jj_scan_token(118)) {
38925 jj_scanpos = xsp;
38926 if (jj_scan_token(120)) {
38927 jj_scanpos = xsp;
38928 if (jj_scan_token(121)) {
38929 jj_scanpos = xsp;
38930 if (jj_scan_token(122)) {
38931 jj_scanpos = xsp;
38932 if (jj_scan_token(124)) {
38933 jj_scanpos = xsp;
38934 if (jj_scan_token(127)) {
38935 jj_scanpos = xsp;
38936 if (jj_scan_token(128)) {
38937 jj_scanpos = xsp;
38938 if (jj_scan_token(131)) {
38939 jj_scanpos = xsp;
38940 if (jj_scan_token(135)) {
38941 jj_scanpos = xsp;
38942 if (jj_scan_token(137)) {
38943 jj_scanpos = xsp;
38944 if (jj_scan_token(139)) {
38945 jj_scanpos = xsp;
38946 if (jj_scan_token(144)) {
38947 jj_scanpos = xsp;
38948 if (jj_scan_token(146)) {
38949 jj_scanpos = xsp;
38950 if (jj_scan_token(147)) {
38951 jj_scanpos = xsp;
38952 if (jj_scan_token(148)) {
38953 jj_scanpos = xsp;
38954 if (jj_scan_token(150)) {
38955 jj_scanpos = xsp;
38956 if (jj_scan_token(152)) {
38957 jj_scanpos = xsp;
38958 if (jj_scan_token(156)) {
38959 jj_scanpos = xsp;
38960 if (jj_scan_token(158)) {
38961 jj_scanpos = xsp;
38962 if (jj_scan_token(159)) {
38963 jj_scanpos = xsp;
38964 if (jj_scan_token(160)) {
38965 jj_scanpos = xsp;
38966 if (jj_scan_token(161)) {
38967 jj_scanpos = xsp;
38968 if (jj_scan_token(167)) {
38969 jj_scanpos = xsp;
38970 if (jj_scan_token(171)) {
38971 jj_scanpos = xsp;
38972 if (jj_scan_token(172)) {
38973 jj_scanpos = xsp;
38974 if (jj_scan_token(175)) {
38975 jj_scanpos = xsp;
38976 if (jj_scan_token(178)) {
38977 jj_scanpos = xsp;
38978 if (jj_scan_token(181)) {
38979 jj_scanpos = xsp;
38980 if (jj_scan_token(183)) {
38981 jj_scanpos = xsp;
38982 if (jj_scan_token(184)) {
38983 jj_scanpos = xsp;
38984 if (jj_scan_token(185)) {
38985 jj_scanpos = xsp;
38986 if (jj_scan_token(187)) {
38987 jj_scanpos = xsp;
38988 if (jj_scan_token(192)) {
38989 jj_scanpos = xsp;
38990 if (jj_scan_token(194)) {
38991 jj_scanpos = xsp;
38992 if (jj_scan_token(195)) {
38993 jj_scanpos = xsp;
38994 if (jj_scan_token(197)) {
38995 jj_scanpos = xsp;
38996 if (jj_scan_token(188)) {
38997 jj_scanpos = xsp;
38998 if (jj_scan_token(189)) {
38999 jj_scanpos = xsp;
39000 if (jj_scan_token(190)) {
39001 jj_scanpos = xsp;
39002 if (jj_scan_token(191)) {
39003 jj_scanpos = xsp;
39004 if (jj_scan_token(201)) {
39005 jj_scanpos = xsp;
39006 if (jj_scan_token(202)) {
39007 jj_scanpos = xsp;
39008 if (jj_scan_token(203)) {
39009 jj_scanpos = xsp;
39010 if (jj_scan_token(204)) {
39011 jj_scanpos = xsp;
39012 if (jj_scan_token(207)) {
39013 jj_scanpos = xsp;
39014 if (jj_scan_token(212)) {
39015 jj_scanpos = xsp;
39016 if (jj_scan_token(215)) {
39017 jj_scanpos = xsp;
39018 if (jj_scan_token(216)) {
39019 jj_scanpos = xsp;
39020 if (jj_scan_token(217)) {
39021 jj_scanpos = xsp;
39022 if (jj_scan_token(220)) {
39023 jj_scanpos = xsp;
39024 if (jj_scan_token(222)) {
39025 jj_scanpos = xsp;
39026 if (jj_scan_token(221)) {
39027 jj_scanpos = xsp;
39028 if (jj_scan_token(224)) {
39029 jj_scanpos = xsp;
39030 if (jj_scan_token(225)) {
39031 jj_scanpos = xsp;
39032 if (jj_scan_token(227)) {
39033 jj_scanpos = xsp;
39034 if (jj_scan_token(246)) {
39035 jj_scanpos = xsp;
39036 if (jj_scan_token(250)) {
39037 jj_scanpos = xsp;
39038 if (jj_scan_token(252)) {
39039 jj_scanpos = xsp;
39040 if (jj_scan_token(255)) {
39041 jj_scanpos = xsp;
39042 if (jj_scan_token(256)) {
39043 jj_scanpos = xsp;
39044 if (jj_scan_token(258)) {
39045 jj_scanpos = xsp;
39046 if (jj_scan_token(259)) {
39047 jj_scanpos = xsp;
39048 if (jj_scan_token(260)) {
39049 jj_scanpos = xsp;
39050 if (jj_scan_token(261)) {
39051 jj_scanpos = xsp;
39052 if (jj_scan_token(263)) {
39053 jj_scanpos = xsp;
39054 if (jj_scan_token(267)) {
39055 jj_scanpos = xsp;
39056 if (jj_scan_token(268)) {
39057 jj_scanpos = xsp;
39058 if (jj_scan_token(269)) {
39059 jj_scanpos = xsp;
39060 if (jj_scan_token(271)) {
39061 jj_scanpos = xsp;
39062 if (jj_scan_token(273)) {
39063 jj_scanpos = xsp;
39064 if (jj_scan_token(280)) {
39065 jj_scanpos = xsp;
39066 if (jj_scan_token(282)) {
39067 jj_scanpos = xsp;
39068 if (jj_scan_token(284)) {
39069 jj_scanpos = xsp;
39070 if (jj_scan_token(285)) {
39071 jj_scanpos = xsp;
39072 if (jj_scan_token(297)) {
39073 jj_scanpos = xsp;
39074 if (jj_scan_token(298)) {
39075 jj_scanpos = xsp;
39076 if (jj_scan_token(299)) {
39077 jj_scanpos = xsp;
39078 if (jj_scan_token(303)) {
39079 jj_scanpos = xsp;
39080 if (jj_scan_token(305)) {
39081 jj_scanpos = xsp;
39082 if (jj_scan_token(308)) {
39083 jj_scanpos = xsp;
39084 if (jj_scan_token(318)) {
39085 jj_scanpos = xsp;
39086 if (jj_scan_token(292)) {
39087 jj_scanpos = xsp;
39088 if (jj_scan_token(432)) {
39089 jj_scanpos = xsp;
39090 if (jj_scan_token(429)) {
39091 jj_scanpos = xsp;
39092 if (jj_scan_token(430)) {
39093 jj_scanpos = xsp;
39094 if (jj_scan_token(431)) return true;
39095 }
39096 }
39097 }
39098 }
39099 }
39100 }
39101 }
39102 }
39103 }
39104 }
39105 }
39106 }
39107 }
39108 }
39109 }
39110 }
39111 }
39112 }
39113 }
39114 }
39115 }
39116 }
39117 }
39118 }
39119 }
39120 }
39121 }
39122 }
39123 }
39124 }
39125 }
39126 }
39127 }
39128 }
39129 }
39130 }
39131 }
39132 }
39133 }
39134 }
39135 }
39136 }
39137 }
39138 }
39139 }
39140 }
39141 }
39142 }
39143 }
39144 }
39145 }
39146 }
39147 }
39148 }
39149 }
39150 }
39151 }
39152 }
39153 }
39154 }
39155 }
39156 }
39157 }
39158 }
39159 }
39160 }
39161 }
39162 }
39163 }
39164 }
39165 }
39166 }
39167 }
39168 }
39169 }
39170 }
39171 }
39172 }
39173 }
39174 }
39175 }
39176 }
39177 }
39178 }
39179 }
39180 }
39181 }
39182 }
39183 }
39184 }
39185 }
39186 }
39187 }
39188 }
39189 }
39190 }
39191 }
39192 }
39193 }
39194 }
39195 }
39196 }
39197 }
39198 }
39199 }
39200 }
39201 }
39202 }
39203 }
39204 }
39205 }
39206 }
39207 }
39208 }
39209 }
39210 }
39211 }
39212 }
39213 }
39214 }
39215 }
39216 }
39217 }
39218 }
39219 }
39220 }
39221 }
39222 }
39223 }
39224 }
39225 }
39226 return false;
39227 }
39228
39229 private boolean jj_3R_577() {
39230 if (jj_scan_token(IN)) return true;
39231 return false;
39232 }
39233
39234 private boolean jj_3R_608() {
39235 if (jj_scan_token(15)) return true;
39236 return false;
39237 }
39238
39239 private boolean jj_3R_576() {
39240 if (jj_scan_token(NOT)) return true;
39241 return false;
39242 }
39243
39244 private boolean jj_3R_575() {
39245 if (jj_scan_token(10)) return true;
39246 return false;
39247 }
39248
39249 private boolean jj_3R_574() {
39250 if (jj_scan_token(15)) return true;
39251 return false;
39252 }
39253
39254 private boolean jj_3R_539() {
39255 Token xsp;
39256 xsp = jj_scanpos;
39257 if (jj_3R_576()) jj_scanpos = xsp;
39258 xsp = jj_scanpos;
39259 if (jj_3R_577()) {
39260 jj_scanpos = xsp;
39261 if (jj_3R_578()) {
39262 jj_scanpos = xsp;
39263 if (jj_3R_579()) {
39264 jj_scanpos = xsp;
39265 if (jj_3R_580()) {
39266 jj_scanpos = xsp;
39267 if (jj_3R_581()) return true;
39268 }
39269 }
39270 }
39271 }
39272 return false;
39273 }
39274
39275 private boolean jj_3R_573() {
39276 if (jj_scan_token(14)) return true;
39277 Token xsp;
39278 xsp = jj_scanpos;
39279 if (jj_3R_608()) jj_scanpos = xsp;
39280 return false;
39281 }
39282
39283 private boolean jj_3R_321() {
39284 if (jj_3R_350()) return true;
39285 return false;
39286 }
39287
39288 private boolean jj_3R_320() {
39289 if (jj_3R_173()) return true;
39290 return false;
39291 }
39292
39293 private boolean jj_3R_116() {
39294 if (jj_3R_190()) return true;
39295 return false;
39296 }
39297
39298 private boolean jj_3R_538() {
39299 Token xsp;
39300 xsp = jj_scanpos;
39301 if (jj_3R_573()) {
39302 jj_scanpos = xsp;
39303 if (jj_3R_574()) return true;
39304 }
39305 xsp = jj_scanpos;
39306 if (jj_3R_575()) jj_scanpos = xsp;
39307 return false;
39308 }
39309
39310 private boolean jj_3_14() {
39311 Token xsp;
39312 while (true) {
39313 xsp = jj_scanpos;
39314 if (jj_3R_116()) { jj_scanpos = xsp; break; }
39315 }
39316 xsp = jj_scanpos;
39317 if (jj_3R_117()) jj_scanpos = xsp;
39318 if (jj_scan_token(BEGIN)) return true;
39319 return false;
39320 }
39321
39322 private boolean jj_3R_319() {
39323 if (jj_scan_token(DECLARE)) return true;
39324 if (jj_3R_191()) return true;
39325 return false;
39326 }
39327
39328 private boolean jj_3R_508() {
39329 Token xsp;
39330 xsp = jj_scanpos;
39331 if (jj_3R_538()) {
39332 jj_scanpos = xsp;
39333 if (jj_3R_539()) {
39334 jj_scanpos = xsp;
39335 if (jj_3R_540()) return true;
39336 }
39337 }
39338 if (jj_3R_507()) return true;
39339 xsp = jj_scanpos;
39340 if (jj_3R_541()) jj_scanpos = xsp;
39341 return false;
39342 }
39343
39344 private boolean jj_3R_271() {
39345 Token xsp;
39346 xsp = jj_scanpos;
39347 if (jj_3R_319()) jj_scanpos = xsp;
39348 if (jj_scan_token(BEGIN)) return true;
39349 while (true) {
39350 xsp = jj_scanpos;
39351 if (jj_3R_320()) { jj_scanpos = xsp; break; }
39352 }
39353 xsp = jj_scanpos;
39354 if (jj_3R_321()) jj_scanpos = xsp;
39355 if (jj_scan_token(END)) return true;
39356 xsp = jj_scanpos;
39357 if (jj_scan_token(420)) jj_scanpos = xsp;
39358 return false;
39359 }
39360
39361 private boolean jj_3R_481() {
39362 if (jj_3R_507()) return true;
39363 Token xsp;
39364 while (true) {
39365 xsp = jj_scanpos;
39366 if (jj_3R_508()) { jj_scanpos = xsp; break; }
39367 }
39368 return false;
39369 }
39370
39371 private boolean jj_3R_185() {
39372 Token xsp;
39373 while (true) {
39374 xsp = jj_scanpos;
39375 if (jj_3R_270()) { jj_scanpos = xsp; break; }
39376 }
39377 if (jj_3R_271()) return true;
39378 if (jj_scan_token(4)) return true;
39379 return false;
39380 }
39381
39382 private boolean jj_3R_511() {
39383 if (jj_scan_token(IS)) return true;
39384 return false;
39385 }
39386
39387 private boolean jj_3R_510() {
39388 if (jj_scan_token(13)) return true;
39389 if (jj_scan_token(10)) return true;
39390 return false;
39391 }
39392
39393 private boolean jj_3R_509() {
39394 if (jj_scan_token(10)) return true;
39395 return false;
39396 }
39397
39398 private boolean jj_3R_113() {
39399 Token xsp;
39400 xsp = jj_scanpos;
39401 if (jj_3R_185()) {
39402 jj_scanpos = xsp;
39403 if (jj_3_15()) return true;
39404 }
39405 return false;
39406 }
39407
39408 private boolean jj_3R_482() {
39409 Token xsp;
39410 xsp = jj_scanpos;
39411 if (jj_3R_509()) {
39412 jj_scanpos = xsp;
39413 if (jj_3R_510()) {
39414 jj_scanpos = xsp;
39415 if (jj_3R_511()) return true;
39416 }
39417 }
39418 if (jj_3R_481()) return true;
39419 return false;
39420 }
39421
39422 private boolean jj_3R_436() {
39423 if (jj_3R_481()) return true;
39424 Token xsp;
39425 while (true) {
39426 xsp = jj_scanpos;
39427 if (jj_3R_482()) { jj_scanpos = xsp; break; }
39428 }
39429 return false;
39430 }
39431
39432 private boolean jj_3R_437() {
39433 if (jj_scan_token(AND)) return true;
39434 if (jj_3R_436()) return true;
39435 return false;
39436 }
39437
39438 private boolean jj_3R_394() {
39439 if (jj_3R_436()) return true;
39440 Token xsp;
39441 while (true) {
39442 xsp = jj_scanpos;
39443 if (jj_3R_437()) { jj_scanpos = xsp; break; }
39444 }
39445 return false;
39446 }
39447
39448 private boolean jj_3R_395() {
39449 if (jj_scan_token(OR)) return true;
39450 if (jj_3R_394()) return true;
39451 return false;
39452 }
39453
39454 private boolean jj_3R_188() {
39455 if (jj_scan_token(3)) return true;
39456 if (jj_scan_token(ATTACH)) return true;
39457 return false;
39458 }
39459
39460 private boolean jj_3R_343() {
39461 if (jj_3R_394()) return true;
39462 Token xsp;
39463 while (true) {
39464 xsp = jj_scanpos;
39465 if (jj_3R_395()) { jj_scanpos = xsp; break; }
39466 }
39467 return false;
39468 }
39469
39470 private boolean jj_3R_236() {
39471 if (jj_scan_token(3)) return true;
39472 if (jj_3R_233()) return true;
39473 return false;
39474 }
39475
39476 private boolean jj_3R_234() {
39477 if (jj_scan_token(AT)) return true;
39478 if (jj_scan_token(TIME)) return true;
39479 if (jj_scan_token(ZONE)) return true;
39480 if (jj_3R_133()) return true;
39481 return false;
39482 }
39483
39484 private boolean jj_3R_139() {
39485 Token xsp;
39486 xsp = jj_scanpos;
39487 if (jj_scan_token(390)) {
39488 jj_scanpos = xsp;
39489 if (jj_scan_token(391)) return true;
39490 }
39491 if (jj_scan_token(5)) return true;
39492 if (jj_3R_233()) return true;
39493 xsp = jj_scanpos;
39494 if (jj_3R_234()) jj_scanpos = xsp;
39495 if (jj_scan_token(AS)) return true;
39496 if (jj_3R_235()) return true;
39497 if (jj_scan_token(7)) return true;
39498 while (true) {
39499 xsp = jj_scanpos;
39500 if (jj_3R_236()) { jj_scanpos = xsp; break; }
39501 }
39502 return false;
39503 }
39504
39505 private boolean jj_3R_228() {
39506 if (jj_3R_229()) return true;
39507 return false;
39508 }
39509
39510 private boolean jj_3R_115() {
39511 Token xsp;
39512 xsp = jj_scanpos;
39513 if (jj_scan_token(2)) {
39514 jj_scanpos = xsp;
39515 if (jj_scan_token(377)) {
39516 jj_scanpos = xsp;
39517 if (jj_scan_token(74)) {
39518 jj_scanpos = xsp;
39519 if (jj_scan_token(78)) {
39520 jj_scanpos = xsp;
39521 if (jj_scan_token(379)) {
39522 jj_scanpos = xsp;
39523 if (jj_scan_token(380)) {
39524 jj_scanpos = xsp;
39525 if (jj_scan_token(381)) {
39526 jj_scanpos = xsp;
39527 if (jj_scan_token(111)) {
39528 jj_scanpos = xsp;
39529 if (jj_scan_token(113)) {
39530 jj_scanpos = xsp;
39531 if (jj_scan_token(382)) {
39532 jj_scanpos = xsp;
39533 if (jj_scan_token(383)) {
39534 jj_scanpos = xsp;
39535 if (jj_scan_token(221)) {
39536 jj_scanpos = xsp;
39537 if (jj_scan_token(384)) {
39538 jj_scanpos = xsp;
39539 if (jj_scan_token(385)) {
39540 jj_scanpos = xsp;
39541 if (jj_scan_token(253)) {
39542 jj_scanpos = xsp;
39543 if (jj_scan_token(294)) {
39544 jj_scanpos = xsp;
39545 if (jj_scan_token(295)) {
39546 jj_scanpos = xsp;
39547 if (jj_scan_token(261)) {
39548 jj_scanpos = xsp;
39549 if (jj_scan_token(386)) {
39550 jj_scanpos = xsp;
39551 if (jj_scan_token(387)) {
39552 jj_scanpos = xsp;
39553 if (jj_scan_token(388)) {
39554 jj_scanpos = xsp;
39555 if (jj_scan_token(75)) {
39556 jj_scanpos = xsp;
39557 if (jj_scan_token(129)) {
39558 jj_scanpos = xsp;
39559 if (jj_scan_token(240)) {
39560 jj_scanpos = xsp;
39561 if (jj_scan_token(99)) {
39562 jj_scanpos = xsp;
39563 if (jj_scan_token(420)) {
39564 jj_scanpos = xsp;
39565 if (jj_3R_188()) return true;
39566 }
39567 }
39568 }
39569 }
39570 }
39571 }
39572 }
39573 }
39574 }
39575 }
39576 }
39577 }
39578 }
39579 }
39580 }
39581 }
39582 }
39583 }
39584 }
39585 }
39586 }
39587 }
39588 }
39589 }
39590 }
39591 }
39592 if (jj_3R_189()) return true;
39593 return false;
39594 }
39595
39596 private boolean jj_3R_227() {
39597 Token xsp;
39598 xsp = jj_scanpos;
39599 if (jj_scan_token(399)) {
39600 jj_scanpos = xsp;
39601 if (jj_scan_token(400)) {
39602 jj_scanpos = xsp;
39603 if (jj_scan_token(395)) return true;
39604 }
39605 }
39606 return false;
39607 }
39608
39609 private boolean jj_3R_114() {
39610 if (jj_3R_186()) return true;
39611 if (jj_3R_187()) return true;
39612 return false;
39613 }
39614
39615 private boolean jj_3R_137() {
39616 if (jj_scan_token(TRIM)) return true;
39617 if (jj_scan_token(5)) return true;
39618 Token xsp;
39619 xsp = jj_scanpos;
39620 if (jj_3R_227()) jj_scanpos = xsp;
39621 xsp = jj_scanpos;
39622 if (jj_3R_228()) jj_scanpos = xsp;
39623 if (jj_scan_token(FROM)) return true;
39624 if (jj_3R_229()) return true;
39625 if (jj_scan_token(7)) return true;
39626 return false;
39627 }
39628
39629 private boolean jj_3_13() {
39630 if (jj_3R_115()) return true;
39631 return false;
39632 }
39633
39634 private boolean jj_3_12() {
39635 if (jj_3R_114()) return true;
39636 return false;
39637 }
39638
39639 private boolean jj_3_11() {
39640 if (jj_3R_113()) return true;
39641 return false;
39642 }
39643
39644 private boolean jj_3_10() {
39645 if (jj_3R_112()) return true;
39646 return false;
39647 }
39648
39649 private boolean jj_3_9() {
39650 if (jj_3R_111()) return true;
39651 return false;
39652 }
39653
39654 private boolean jj_3_8() {
39655 if (jj_3R_110()) return true;
39656 return false;
39657 }
39658
39659 private boolean jj_3_7() {
39660 if (jj_3R_109()) return true;
39661 return false;
39662 }
39663
39664 private boolean jj_3_6() {
39665 if (jj_3R_108()) return true;
39666 return false;
39667 }
39668
39669 private boolean jj_3_5() {
39670 if (jj_3R_107()) return true;
39671 return false;
39672 }
39673
39674 private boolean jj_3_4() {
39675 if (jj_3R_106()) return true;
39676 return false;
39677 }
39678
39679 private boolean jj_3_3() {
39680 if (jj_3R_105()) return true;
39681 return false;
39682 }
39683
39684 private boolean jj_3_2() {
39685 if (jj_3R_104()) return true;
39686 return false;
39687 }
39688
39689 private boolean jj_3_1() {
39690 if (jj_3R_103()) return true;
39691 return false;
39692 }
39693
39694 private boolean jj_3R_232() {
39695 if (jj_scan_token(ELSE)) return true;
39696 if (jj_3R_233()) return true;
39697 return false;
39698 }
39699
39700 private boolean jj_3R_231() {
39701 if (jj_scan_token(WHEN)) return true;
39702 if (jj_3R_233()) return true;
39703 if (jj_scan_token(THEN)) return true;
39704 if (jj_3R_233()) return true;
39705 return false;
39706 }
39707
39708 private boolean jj_3R_230() {
39709 if (jj_3R_233()) return true;
39710 return false;
39711 }
39712
39713 private boolean jj_3R_138() {
39714 if (jj_scan_token(CASE)) return true;
39715 Token xsp;
39716 xsp = jj_scanpos;
39717 if (jj_3R_230()) jj_scanpos = xsp;
39718 if (jj_3R_231()) return true;
39719 while (true) {
39720 xsp = jj_scanpos;
39721 if (jj_3R_231()) { jj_scanpos = xsp; break; }
39722 }
39723 xsp = jj_scanpos;
39724 if (jj_3R_232()) jj_scanpos = xsp;
39725 if (jj_scan_token(END)) return true;
39726 return false;
39727 }
39728
39729 private boolean jj_3R_342() {
39730 if (jj_3R_133()) return true;
39731 if (jj_scan_token(9)) return true;
39732 if (jj_scan_token(10)) return true;
39733 if (jj_3R_233()) return true;
39734 return false;
39735 }
39736
39737 private boolean jj_3R_397() {
39738 if (jj_scan_token(CC_ELSE)) return true;
39739 if (jj_3R_233()) return true;
39740 return false;
39741 }
39742
39743 private boolean jj_3R_396() {
39744 if (jj_scan_token(CC_ELSIF)) return true;
39745 if (jj_3R_343()) return true;
39746 if (jj_scan_token(CC_THEN)) return true;
39747 if (jj_3R_233()) return true;
39748 return false;
39749 }
39750
39751 private boolean jj_3R_344() {
39752 if (jj_scan_token(CC_IF)) return true;
39753 if (jj_3R_343()) return true;
39754 if (jj_scan_token(CC_THEN)) return true;
39755 if (jj_3R_233()) return true;
39756 Token xsp;
39757 while (true) {
39758 xsp = jj_scanpos;
39759 if (jj_3R_396()) { jj_scanpos = xsp; break; }
39760 }
39761 while (true) {
39762 xsp = jj_scanpos;
39763 if (jj_3R_397()) { jj_scanpos = xsp; break; }
39764 }
39765 if (jj_scan_token(CC_END)) return true;
39766 return false;
39767 }
39768
39769 private boolean jj_3_45() {
39770 if (jj_3R_133()) return true;
39771 if (jj_scan_token(9)) return true;
39772 if (jj_scan_token(10)) return true;
39773 return false;
39774 }
39775
39776 private boolean jj_3R_109() {
39777 if (jj_scan_token(ALTER)) return true;
39778 if (jj_scan_token(TRIGGER)) return true;
39779 if (jj_3R_179()) return true;
39780 if (jj_scan_token(4)) return true;
39781 return false;
39782 }
39783
39784 private boolean jj_3R_302() {
39785 if (jj_3R_344()) return true;
39786 return false;
39787 }
39788
39789 private boolean jj_3R_301() {
39790 if (jj_3R_343()) return true;
39791 return false;
39792 }
39793
39794 private boolean jj_3R_300() {
39795 if (jj_3R_342()) return true;
39796 return false;
39797 }
39798
39799 private boolean jj_3R_318() {
39800 if (jj_3R_377()) return true;
39801 return false;
39802 }
39803
39804 private boolean jj_3R_233() {
39805 Token xsp;
39806 xsp = jj_scanpos;
39807 if (jj_3R_300()) {
39808 jj_scanpos = xsp;
39809 if (jj_3R_301()) {
39810 jj_scanpos = xsp;
39811 if (jj_3R_302()) return true;
39812 }
39813 }
39814 return false;
39815 }
39816
39817 private boolean jj_3R_317() {
39818 if (jj_3R_186()) return true;
39819 return false;
39820 }
39821
39822 private boolean jj_3R_267() {
39823 Token xsp;
39824 xsp = jj_scanpos;
39825 if (jj_3R_317()) {
39826 jj_scanpos = xsp;
39827 if (jj_3R_318()) return true;
39828 }
39829 return false;
39830 }
39831
39832 private boolean jj_3R_377() {
39833 Token xsp;
39834 xsp = jj_scanpos;
39835 if (jj_scan_token(361)) {
39836 jj_scanpos = xsp;
39837 if (jj_scan_token(360)) {
39838 jj_scanpos = xsp;
39839 if (jj_scan_token(355)) {
39840 jj_scanpos = xsp;
39841 if (jj_scan_token(354)) {
39842 jj_scanpos = xsp;
39843 if (jj_scan_token(359)) {
39844 jj_scanpos = xsp;
39845 if (jj_scan_token(364)) return true;
39846 }
39847 }
39848 }
39849 }
39850 }
39851 return false;
39852 }
39853
39854 private boolean jj_3R_423() {
39855 if (jj_3R_198()) return true;
39856 return false;
39857 }
39858
39859 private boolean jj_3R_122() {
39860 if (jj_3R_198()) return true;
39861 return false;
39862 }
39863
39864 private boolean jj_3R_273() {
39865 if (jj_scan_token(DISASSOCIATE)) return true;
39866 if (jj_scan_token(STATISTICS)) return true;
39867 return false;
39868 }
39869
39870 private boolean jj_3_84() {
39871 if (jj_3R_124()) return true;
39872 if (jj_scan_token(3)) return true;
39873 return false;
39874 }
39875
39876 private boolean jj_3R_501() {
39877 if (jj_scan_token(IS)) return true;
39878 Token xsp;
39879 while (true) {
39880 xsp = jj_scanpos;
39881 if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
39882 }
39883 if (jj_3R_404()) return true;
39884 return false;
39885 }
39886
39887 private boolean jj_3R_272() {
39888 if (jj_scan_token(ASSOCIATE)) return true;
39889 if (jj_scan_token(STATISTICS)) return true;
39890 return false;
39891 }
39892
39893 private boolean jj_3R_500() {
39894 if (jj_scan_token(RETURN)) return true;
39895 if (jj_3R_235()) return true;
39896 return false;
39897 }
39898
39899 private boolean jj_3R_499() {
39900 if (jj_3R_385()) return true;
39901 return false;
39902 }
39903
39904 private boolean jj_3R_186() {
39905 Token xsp;
39906 xsp = jj_scanpos;
39907 if (jj_scan_token(47)) {
39908 jj_scanpos = xsp;
39909 if (jj_scan_token(344)) {
39910 jj_scanpos = xsp;
39911 if (jj_3R_272()) {
39912 jj_scanpos = xsp;
39913 if (jj_scan_token(346)) {
39914 jj_scanpos = xsp;
39915 if (jj_scan_token(75)) {
39916 jj_scanpos = xsp;
39917 if (jj_scan_token(83)) {
39918 jj_scanpos = xsp;
39919 if (jj_3R_273()) {
39920 jj_scanpos = xsp;
39921 if (jj_scan_token(99)) {
39922 jj_scanpos = xsp;
39923 if (jj_scan_token(129)) {
39924 jj_scanpos = xsp;
39925 if (jj_scan_token(357)) {
39926 jj_scanpos = xsp;
39927 if (jj_scan_token(233)) {
39928 jj_scanpos = xsp;
39929 if (jj_scan_token(240)) {
39930 jj_scanpos = xsp;
39931 if (jj_scan_token(365)) {
39932 jj_scanpos = xsp;
39933 if (jj_scan_token(350)) return true;
39934 }
39935 }
39936 }
39937 }
39938 }
39939 }
39940 }
39941 }
39942 }
39943 }
39944 }
39945 }
39946 }
39947 return false;
39948 }
39949
39950 private boolean jj_3R_198() {
39951 if (jj_scan_token(CURSOR)) return true;
39952 if (jj_3R_124()) return true;
39953 Token xsp;
39954 xsp = jj_scanpos;
39955 if (jj_3R_499()) jj_scanpos = xsp;
39956 xsp = jj_scanpos;
39957 if (jj_3R_500()) jj_scanpos = xsp;
39958 xsp = jj_scanpos;
39959 if (jj_3R_501()) jj_scanpos = xsp;
39960 if (jj_scan_token(4)) return true;
39961 return false;
39962 }
39963
39964 private boolean jj_3R_562() {
39965 if (jj_3R_182()) return true;
39966 return false;
39967 }
39968
39969 private boolean jj_3R_632() {
39970 if (jj_3R_182()) return true;
39971 return false;
39972 }
39973
39974 private boolean jj_3_79() {
39975 if (jj_3R_124()) return true;
39976 if (jj_scan_token(3)) return true;
39977 return false;
39978 }
39979
39980 private boolean jj_3_83() {
39981 if (jj_3R_122()) return true;
39982 return false;
39983 }
39984
39985 private boolean jj_3R_269() {
39986 if (jj_3R_267()) return true;
39987 return false;
39988 }
39989
39990 private boolean jj_3_82() {
39991 if (jj_3R_121()) return true;
39992 return false;
39993 }
39994
39995 private boolean jj_3R_561() {
39996 if (jj_3R_182()) return true;
39997 return false;
39998 }
39999
40000 private boolean jj_3_81() {
40001 if (jj_3R_152()) return true;
40002 return false;
40003 }
40004
40005 private boolean jj_3_80() {
40006 if (jj_3R_119()) return true;
40007 return false;
40008 }
40009
40010 private boolean jj_3R_424() {
40011 if (jj_scan_token(IDENTIFIER)) return true;
40012 return false;
40013 }
40014
40015 private boolean jj_3R_176() {
40016 if (jj_3R_267()) return true;
40017 return false;
40018 }
40019
40020 private boolean jj_3R_151() {
40021 if (jj_scan_token(6)) return true;
40022 if (jj_3R_124()) return true;
40023 return false;
40024 }
40025
40026 private boolean jj_3R_150() {
40027 if (jj_scan_token(6)) return true;
40028 if (jj_3R_124()) return true;
40029 return false;
40030 }
40031
40032 private boolean jj_3R_629() {
40033 if (jj_scan_token(3)) return true;
40034 Token xsp;
40035 xsp = jj_scanpos;
40036 if (jj_scan_token(420)) {
40037 jj_scanpos = xsp;
40038 if (jj_scan_token(428)) {
40039 jj_scanpos = xsp;
40040 if (jj_3R_632()) return true;
40041 }
40042 }
40043 return false;
40044 }
40045
40046 private boolean jj_3_75() {
40047 if (jj_3R_124()) return true;
40048 if (jj_scan_token(3)) return true;
40049 return false;
40050 }
40051
40052 private boolean jj_3R_598() {
40053 if (jj_scan_token(9)) return true;
40054 if (jj_scan_token(10)) return true;
40055 return false;
40056 }
40057
40058 private boolean jj_3R_289() {
40059 if (jj_scan_token(PARAMETERS)) return true;
40060 if (jj_3R_563()) return true;
40061 return false;
40062 }
40063
40064 private boolean jj_3_78() {
40065 if (jj_3R_124()) return true;
40066 if (jj_scan_token(3)) return true;
40067 return false;
40068 }
40069
40070 private boolean jj_3R_565() {
40071 Token xsp;
40072 xsp = jj_scanpos;
40073 if (jj_3R_598()) {
40074 jj_scanpos = xsp;
40075 if (jj_scan_token(92)) return true;
40076 }
40077 if (jj_3R_233()) return true;
40078 return false;
40079 }
40080
40081 private boolean jj_3R_525() {
40082 if (jj_scan_token(5)) return true;
40083 if (jj_3R_127()) return true;
40084 if (jj_scan_token(7)) return true;
40085 return false;
40086 }
40087
40088 private boolean jj_3_74() {
40089 if (jj_scan_token(OF)) return true;
40090 if (jj_3R_124()) return true;
40091 Token xsp;
40092 while (true) {
40093 xsp = jj_scanpos;
40094 if (jj_3R_151()) { jj_scanpos = xsp; break; }
40095 }
40096 return false;
40097 }
40098
40099 private boolean jj_3R_288() {
40100 if (jj_scan_token(WITH)) return true;
40101 if (jj_scan_token(CONTEXT)) return true;
40102 return false;
40103 }
40104
40105
40106 public PLSQLParserTokenManager token_source;
40107 SimpleCharStream jj_input_stream;
40108
40109 public Token token;
40110
40111 public Token jj_nt;
40112 private Token jj_scanpos, jj_lastpos;
40113 private int jj_la;
40114 private int jj_gen;
40115 final private int[] jj_la1 = new int[458];
40116 static private int[] jj_la1_0;
40117 static private int[] jj_la1_1;
40118 static private int[] jj_la1_2;
40119 static private int[] jj_la1_3;
40120 static private int[] jj_la1_4;
40121 static private int[] jj_la1_5;
40122 static private int[] jj_la1_6;
40123 static private int[] jj_la1_7;
40124 static private int[] jj_la1_8;
40125 static private int[] jj_la1_9;
40126 static private int[] jj_la1_10;
40127 static private int[] jj_la1_11;
40128 static private int[] jj_la1_12;
40129 static private int[] jj_la1_13;
40130 static {
40131 jj_la1_init_0();
40132 jj_la1_init_1();
40133 jj_la1_init_2();
40134 jj_la1_init_3();
40135 jj_la1_init_4();
40136 jj_la1_init_5();
40137 jj_la1_init_6();
40138 jj_la1_init_7();
40139 jj_la1_init_8();
40140 jj_la1_init_9();
40141 jj_la1_init_10();
40142 jj_la1_init_11();
40143 jj_la1_init_12();
40144 jj_la1_init_13();
40145 }
40146 private static void jj_la1_init_0() {
40147 jj_la1_0 = new int[] {0x20000c,0x0,0x0,0x2,0xc,0x200000,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x8,0x0,0x8,0x0,0x0,0x40,0x0,0x0,0x8,0x40,0x8,0x0,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x100,0x200,0x200,0x0,0x20,0x0,0x20,0x0,0x40,0x0,0x0,0x0,0x200,0x200,0x4,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x230020,0x0,0x0,0x10,0x30020,0x230020,0x200000,0x30020,0x0,0x0,0x0,0x230020,0x230020,0x230020,0x230020,0x0,0x0,0x1000,0x230020,0x0,0x230020,0x0,0x230020,0x0,0x0,0x0,0x1000,0x30020,0x0,0x30020,0x0,0x0,0x0,0x0,0x0,0x30020,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x40,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x230020,0x0,0x230020,0x0,0x230020,0x0,0x20,0x20,0x0,0x0,0x0,0x40,0x40,0x0,0x20,0x0,0x0,0x0,0x40,0x20,0x0,0x0,0x0,0x200,0x200,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x20,0x0,0x20,0x0,0x30020,0x0,0x0,0x30020,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x20,0x0,0x0,0x8,0x0,0x0,0x2400,0x2400,0xc000,0x8000,0xc000,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc000,0x0,0x0,0x70000,0x70000,0x40000,0x180002,0x180002,0x30000,0x30020,0x20,0x0,0x0,0x0,0x40,0x0,0x20,0x20,0x20,0x40,0x0,0x0,0x20,0x30020,0x0,0x2c,0x0,0x0,0x0,0x808,0x8,0x30020,0x40,0x800000,0x0,0x0,0x0,0x40,0x30000,0x30000,0x40,0x0,0x0,0x40,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x20,0x12,0x0,0x0,0x12,0x0,0x12,0x0,0x0,0x0,0x0,0x0,0x12,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x12,0x0,0x12,0x12,0x40,0x40,0x0,0x20,0x40,0x80,0x0,0x0,0x20,0x40,0x80,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x30000,0x30000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
40148 }
40149 private static void jj_la1_init_1() {
40150 jj_la1_1 = new int[] {0x2008000,0x0,0x0,0x0,0x0,0x0,0x0,0x52e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x30,0x800000,0x80000,0xfdfffff8,0x80000,0x0,0x0,0x0,0x0,0x0,0x80000,0x52e43c38,0x0,0x2000000,0xfdfffff8,0x80000,0x0,0x0,0xfdfffff8,0xfdfffff8,0xfdfffff8,0x0,0xfdfffff8,0xfdfffff8,0x0,0xfdfffff8,0xfdfffff8,0x0,0x0,0x0,0x0,0x800000,0x30,0x0,0x0,0x0,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x2000,0x80000,0x0,0x52e43c38,0x0,0xfdfffff8,0xfffffff8,0x80000,0x882000,0x0,0x0,0x78e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x28000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x52e43c38,0x52e43c38,0x0,0x0,0x0,0x52e43c38,0x52e43c38,0x0,0x50e43c38,0x0,0x0,0x0,0x52e43c38,0x52e43c38,0x52e43c38,0x52e43c38,0x0,0x0,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x50e43c38,0x50e43c38,0x0,0x50e43c38,0x0,0x50e43c38,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x52e43c38,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x78e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x0,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x200000,0x0,0x0,0x10000,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x4000,0x4000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x50e43c38,0x50e43c38,0x0,0x0,0x50e43c38,0x0,0x50e43c38,0x0,0x200000,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x0,0x80000,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x50e43ff8,0x0,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x50e43c38,0x50e43c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x52e43c38,0x0,0xfdfffff8,0xfffffff8,0x80000,0x0,0x0,0x0,0x0,0x0,0x30,0x800000,0x80000,0x80000,0x0,0x0,0x0,0x80000,0x0,0x80000,0x0,0xfdfffff8,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x8000,0x0,0x0,0x1000,0x0,0x1000,0x0,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x400000,0x400000,0x1000,0x30,0x800000,0x80000,0xfdfffff8,0x0,0xfdfffff8,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfdfffff8,0x0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x0,0x0,0x8000,0x0,0xfdfffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x52e43c38,0x0,0x0,0xfdfffff8,0x0,0x0,0xfdfffff8,0x0,0x8000,0x0,0x8000,0xfdfffff8,0x8000,0x0,0x8000,0x841bc000,0x40e03c30,0xfdfffff8,0x50e43c38,0x79e43ff8,0x28840000,0x0,};
40151 }
40152 private static void jj_la1_init_2() {
40153 jj_la1_2 = new int[] {0x24085c00,0x20001000,0x20001000,0x0,0x4c00,0x0,0x4000000,0x27d71f47,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x27d71f47,0x0,0x0,0x7fffffff,0x0,0x0,0x490000,0x7fffffff,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x80000,0x80000000,0x0,0x0,0x0,0x0,0x0,0x80,0x7fffffff,0x0,0x80,0x80,0x0,0x0,0x0,0x0,0x80000000,0x0,0x0,0x0,0x27d71f47,0x0,0x7fffffff,0x7fffffff,0x0,0x80000000,0x0,0x0,0xbd71f5b,0x10000000,0x10000000,0x90000,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x2d71f43,0x0,0x0,0x0,0x0,0x8,0x1,0x8,0x0,0x9000018,0x0,0x0,0x8,0x1,0x0,0x0,0x1000000,0x0,0x2000000,0x2000000,0x0,0x2000000,0x0,0x0,0x0,0x27d71f47,0x27d71f47,0x0,0x20001000,0x0,0x7d71f47,0x27d71f47,0x0,0x3d71f47,0x0,0x0,0x0,0x27d71f47,0x27d71f47,0x27d71f47,0x27d71f47,0x0,0x0,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x3d71f47,0x2d71f43,0x0,0x2d71f43,0x0,0x2d71f43,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x27d71f47,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbd71f5b,0x0,0x0,0x0,0x10000000,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x3d71f47,0x0,0x0,0x0,0x0,0x0,0x3d71f47,0x3d71f47,0x3d71f47,0x0,0x1000000,0x2d71f43,0x0,0x3d71f47,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x3d71f47,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x2d71f43,0x0,0x0,0x0,0x80,0x0,0x80,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x0,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2d71f43,0x2d75f43,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x10000,0x80000000,0x0,0x0,0x0,0x0,0x0,0x27d71f47,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x7fffffff,0x0,0x10000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000,0x10000,0x0,0x0,0x0,0x10000,0x10000,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x40000,0x0,0x40000,0x0,0x0,0x2,0x2,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x20000000,0x0,0x20080800,0x0,0x20000000,0x0,0x20080800,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x27d71f47,0x0,0x0,0x7fffffff,0x0,0x480000,0x7fffffff,0x0,0x80800,0x0,0x80800,0x7fffffff,0x80800,0x0,0x80800,0x790860a8,0x2d71f43,0x7fffffff,0x2d71f43,0x2bf79f5b,0x9200008,0x0,};
40154 }
40155 private static void jj_la1_init_3() {
40156 jj_la1_3 = new int[] {0x20028008,0x0,0x0,0x0,0x28008,0x0,0x0,0xeefead31,0x1000,0x0,0x0,0x10,0x10,0x0,0x0,0x0,0x0,0x0,0xfffffdff,0x0,0x0,0x10,0x10,0x0,0x0,0x0,0xeefead31,0x1000,0x0,0xfffffdff,0x0,0x0,0x20800000,0xfffffdff,0xfffffdff,0xfffffdff,0x0,0xfffffdff,0xfffffdff,0x0,0xfffffdff,0xfffffdff,0x0,0x10,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0x1000,0xfffffdff,0xfffffdff,0x0,0x0,0x0,0x0,0x69be2d31,0x0,0x0,0x20800000,0x0,0x0,0x0,0x20000000,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0xeefead31,0x0,0x8000,0x0,0xeefead31,0xeefead31,0x0,0x68be2d31,0x0,0x40,0x0,0xeefead31,0xeefead31,0xeefead31,0xeefead31,0x0,0x0,0x0,0xeefead31,0x0,0xeefead31,0x0,0xeefead31,0x80,0x40,0x0,0x0,0x68be2d31,0x0,0x68be2d31,0x68be2d31,0x0,0x68be2d31,0x0,0x68be2d31,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0x0,0xeefead31,0x0,0xeefead31,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x69be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x68be2d31,0x0,0x40,0x0,0x400,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x800,0x2,0x2,0x10000000,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x68be2d31,0x68be2d31,0x0,0x200000,0x68be2d31,0x0,0x68be2d31,0x0,0x0,0x200000,0x200000,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x20000000,0x0,0x20000000,0x20000000,0x40000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x68be2d31,0x68be2d31,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xeefead31,0x1000,0xfffffdff,0xfffffdff,0x0,0x0,0x10,0x10,0x0,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffffdff,0xfffffdff,0x0,0x800000,0x0,0x0,0x800000,0x0,0x800000,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x800020,0x800020,0x0,0x0,0x0,0x800000,0x800000,0x8,0x0,0x0,0x0,0xfffffdff,0x0,0xfffffdff,0x0,0x800000,0x0,0x800000,0x0,0x0,0x0,0x8000000,0x8002000,0x0,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x10,0x10,0x0,0x2000000,0x0,0x0,0x8,0x0,0x0,0x0,0x8,0x0,0xfffffdff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x101,0x101,0x0,0x0,0x0,0x0,0xeefead31,0x0,0x0,0xfffffdff,0x0,0x20000000,0xfffffdff,0x0,0x8,0x0,0x8,0xfffffdff,0x8,0x0,0x8,0x1301404a,0x68be2d31,0xfffffdff,0x68be2d31,0x6dbfadb5,0x1000000,0x0,};
40157 }
40158 private static void jj_la1_init_4() {
40159 jj_la1_4 = new int[] {0x80010002,0x80010000,0x80010000,0x0,0x2,0x0,0x0,0xaea3d1b4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0xffffdbbd,0x1000000,0x0,0x0,0x0,0x0,0x0,0x1000000,0xaea3d1b4,0x0,0x0,0xffffdbbd,0x1000000,0x0,0x20000,0xffffdbbd,0xffffdbbd,0xffffdbbd,0x0,0xffffdbbd,0xffffdbbd,0x0,0xffffdbbd,0xffffdbbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffdbbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0xaea3d1b4,0x0,0xffffdbbd,0xffffdbbd,0x1000000,0x1000000,0x200,0x200,0x2ea6d134,0x0,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0xffffdbbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x200000,0x0,0x20,0x20,0x0,0x20,0x0,0x0,0x0,0xaea3d1b4,0xaea3d1b4,0x0,0x80010000,0x0,0x2ea2d1b4,0xaea3d1b4,0x0,0x2ea2d134,0x0,0x0,0x0,0xaea3d1b4,0xaea3d1b4,0xaea3d1b4,0xaea3d1b4,0x0,0x0,0x0,0xaea3d1b4,0x0,0xaea3d1b4,0x0,0xaea3d1b4,0x0,0x0,0x1000,0x0,0x2ea2d134,0x0,0x2ea2d134,0x2ea2d134,0x0,0x2ea2d134,0x0,0x2ea2d134,0x2ea2d134,0x600,0x600,0x0,0x600,0x600,0x0,0x0,0x0,0x0,0x20000000,0x0,0x400000,0x0,0x200,0x200,0x0,0x0,0x200,0x200,0x0,0x0,0x0,0x0,0xaea3d1b4,0x0,0xaea3d1b4,0x0,0xaea3d1b4,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x2ea6d134,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x2ea2d134,0x0,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0x0,0x1000000,0x1000000,0x10000200,0x0,0x0,0x0,0x0,0x0,0x0,0x10000200,0x100000,0x0,0x0,0x10000200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x2ea2d134,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x2ea2d134,0x2ea2d134,0x0,0x200000,0x2ea2d134,0x0,0x2ea2d134,0x0,0x0,0x200000,0x0,0x0,0x0,0x0,0x2ea2d134,0x0,0x0,0x0,0x0,0xffffdbbd,0x0,0x0,0x0,0x0,0x2eaad134,0x4,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2ea2d134,0x2ea2d134,0x0,0x0,0x4000,0x4000,0x0,0x20000,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0xaea3d1b4,0x0,0xffffdbbd,0xffffdbbd,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x1000000,0x0,0x0,0x0,0x1000000,0x0,0x1000000,0x0,0xffffdbbd,0xffffdbbd,0x0,0x20000,0x0,0x0,0x20000,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20020000,0x20020000,0x0,0x0,0x0,0x20000,0x20000,0x0,0x0,0x0,0x1000000,0xffffdbbd,0x0,0xffffdbbd,0x0,0x20000,0x0,0x20000,0x2000,0x0,0x2000,0x0,0x0,0x800000,0x800000,0xffffdbbd,0x0,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x10000,0x0,0x10002,0x0,0x10000,0x0,0x10002,0x0,0xffffdbbd,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xaea3d1b4,0x0,0x0,0xffffdbbd,0x0,0x0,0xffffdbbd,0x0,0x2,0x0,0x2,0xffffdbbd,0x2,0x0,0x2,0x91550a4b,0x2ea2d134,0xffffdbbd,0x2ea2d134,0x2eaed134,0x240020,0x0,};
40160 }
40161 private static void jj_la1_init_5() {
40162 jj_la1_5 = new int[] {0x20,0x20,0x20,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0xffedffff,0x0,0x0,0x800014,0xffedffff,0xffedffff,0xffedffff,0x0,0xffedffff,0xffedffff,0x0,0xffedffff,0xffedffff,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0xffedffff,0xffedffff,0x0,0x0,0x0,0x0,0xfc49ef7f,0x0,0x0,0x800014,0x0,0x0,0x0,0x0,0x0,0xffedffff,0x800000,0x2800000,0x0,0x0,0x0,0x0,0x0,0x0,0x4496f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0xf800c001,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2100,0x2100,0x0,0x2100,0x0,0x0,0x0,0x6cb6f7e,0x6cb6f7e,0x0,0x20,0x0,0x6cb6f7e,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x0,0x0,0x6cb6f7e,0x6cb6f7e,0x6cb6f7e,0x6cb6f7e,0x0,0x0,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x4496f7e,0x0,0x4496f7e,0x0,0x4496f7e,0x6cb6f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x6cb6f7e,0x0,0x0,0x0,0x800000,0x0,0xf0000000,0x0,0x0,0x0,0x0,0x800000,0x0,0x0,0x0,0xfc49ef7f,0x0,0x800000,0x2800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0x6cb6f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x64b6f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800010,0x0,0x0,0x0,0x800000,0x10,0x0,0x10,0x0,0x0,0x0,0x800010,0x0,0x0,0x0,0x0,0x0,0x800,0x800,0x0,0x6cb6f7e,0x6cb6f7e,0x800000,0x0,0x0,0x0,0x0,0x64b6f7e,0x6496f7e,0x64b6f7e,0x0,0x2000000,0x4496f7e,0x0,0x6cb6f7e,0x0,0x0,0x2000000,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x0,0x0,0x4496f7e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x2800000,0x0,0x80000,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4496f7e,0x4496f7e,0x0,0x0,0x0,0x0,0x0,0x800000,0x800000,0x0,0x4,0x4,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0xffedffff,0xffedffff,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffedffff,0xffedffff,0x0,0x800014,0x0,0x0,0x2800000,0x800000,0x2000000,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0x400,0x0,0x0,0x0,0x800014,0x800014,0x0,0x0,0x0,0x800014,0x800014,0x400,0x0,0x0,0x0,0xffedffff,0x0,0xffedffff,0x0,0x2800000,0x800000,0x2000000,0x800000,0x800000,0x800000,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x0,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffedffff,0x10000,0x10000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6cb6f7e,0x0,0x0,0xffedffff,0x0,0x0,0xffedffff,0x0,0x0,0x0,0x0,0xffedffff,0x0,0x0,0x0,0xb901081,0x449677c,0xffedffff,0x4496f7e,0xfc6def7f,0xf800e201,0x0,};
40163 }
40164 private static void jj_la1_init_6() {
40165 jj_la1_6 = new int[] {0xa0020000,0x0,0x0,0x0,0x20000000,0x0,0x0,0xcc2b6392,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0x800,0x0,0x0,0x0,0x20000,0x0,0xcc2b6392,0x0,0x0,0xfb9bffbf,0x0,0x4000000,0x80011000,0xff9bffbf,0xff9bffbf,0xff9bffbf,0x0,0xff9bffbf,0xff9bffbf,0x0,0xff9bffbf,0xff9bffbf,0x800,0x0,0x0,0x0,0x440000,0x0,0x0,0x0,0x0,0x0,0x1000,0xfb9bffbf,0x0,0x1000,0x1000,0x0,0x0,0x0,0x0,0x440000,0x0,0x0,0x4000000,0xcc2b6392,0x0,0xfb9bffbf,0xff9bffbf,0x0,0x440000,0x8000,0x0,0xcb8b6393,0x0,0x0,0x80011000,0x0,0x0,0x0,0x80000000,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3800001,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0xcc2b6392,0xcc2b6392,0x0,0x0,0x0,0xcc2b6392,0xcc2b6392,0x0,0xc80b6392,0x0,0x0,0x0,0xcc2b6392,0xcc2b6392,0xcc2b6392,0xcc2b6392,0x0,0x0,0x0,0xcc2b6392,0x0,0xcc2b6392,0x0,0xcc2b6392,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0xc80b6392,0xc80b6392,0x0,0xc80b6392,0x0,0xc80b6392,0xc80b6392,0x8000,0x8000,0x0,0x8000,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x8000,0x8000,0x0,0x8000,0x8000,0x8000,0x0,0x0,0x0,0x0,0xcc2b6392,0x0,0xcc2b6392,0x0,0xcc2b6392,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xcb8b6393,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0xc80b6392,0x0,0x0,0x40,0x0,0x40,0xc80b6392,0xc80b6392,0xc80b6392,0x0,0x0,0xc80b6392,0x0,0xc80b6392,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0xc80b6392,0x0,0x0,0x0,0x1000,0x0,0x1000,0x80020000,0x80020000,0x0,0x80020000,0x80020000,0x0,0x0,0x8000000,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x800,0x0,0x0,0x0,0xc80b6392,0xc80b6392,0x0,0x0,0x200,0x200,0x0,0x10000,0x0,0x10000,0x1000,0x1000,0x0,0x0,0x40000,0x400000,0x0,0x0,0x0,0xcc2b6392,0x0,0xfb9bffbf,0xff9bffbf,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff9bffbf,0xff9bffbf,0x0,0x11000,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x11000,0x11000,0x0,0x0,0x0,0x11000,0x11000,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0x0,0x0,0x0,0x0,0xfb9bffbf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xcc2b6392,0x0,0x0,0xff9bffbf,0x4000000,0x80000000,0xfb9bffbf,0x0,0x0,0x800,0x0,0xfb9bffbf,0x0,0x0,0x0,0x10101c28,0x880b6192,0xfb9bffbf,0xc80b6392,0xff8be397,0x3800005,0x0,};
40166 }
40167 private static void jj_la1_init_7() {
40168 jj_la1_7 = new int[] {0x25030200,0x5020000,0x5020000,0x0,0x20010000,0x0,0x0,0x2fbeebfe,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfe,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0xbffeebff,0xbffeebff,0xbffeebff,0x0,0xbffeebff,0xbffeebff,0x0,0xbffeebff,0xbffeebff,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x100,0x1000,0x0,0x0,0x0,0x2fbeebfe,0x0,0xbffeebff,0xbffeebff,0x0,0x1000,0x0,0x0,0x2bbeebfc,0x0,0x0,0x0,0x0,0x2000,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x400000,0x0,0x0,0x2bbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100008,0x100058,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x2000000,0x0,0x2000000,0x0,0x0,0x0,0x2fbeebfe,0x2fbeebfe,0x0,0x25020000,0x0,0x2fbeebfe,0x2fbeebfe,0x0,0x2fbeebfc,0x0,0x0,0x0,0x2fbeebfe,0x2fbeebfe,0x2fbeebfe,0x2fbeebfe,0x0,0x8000,0x0,0x2fbeebfe,0x0,0x2fbeebfe,0x0,0x2fbeebfe,0x0,0x0,0x0,0x0,0x2fbeebfc,0x800000,0x2fbeebfc,0x2bbeebfc,0x0,0x2bbeebfc,0x0,0x2bbeebfc,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x6000,0x0,0x6000,0x2fbeebfe,0x0,0x2fbeebfe,0x0,0x2fbeebfe,0x0,0x4,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000,0x0,0x2bbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2000,0x0,0x0,0x2fbeebfc,0x0,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfc,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x2fbeebfc,0x2fbeebfc,0x2fbeebfc,0x0,0x0,0x2bbeebfc,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfc,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x2bbeebfc,0x4,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x2bbeebfc,0x2bbeebfc,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x2fbeebfe,0x0,0xbffeebff,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10200,0x0,0x0,0x0,0x10200,0x0,0xbffeebff,0x0,0x0,0x0,0x0,0x8000,0x8000,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fbeebfe,0x0,0x0,0xbffeebff,0x0,0x0,0xbffeebff,0x0,0x10200,0x0,0x10200,0xbffeebff,0x10200,0x0,0x10200,0xe4010409,0x2bbeebf4,0xbffeebff,0x2bbeebfc,0x3bfeebfe,0x22740078,0x0,};
40169 }
40170 private static void jj_la1_init_8() {
40171 jj_la1_8 = new int[] {0x14000020,0x0,0x0,0x0,0x20,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x5afd675e,0x0,0x0,0x7fffffff,0x0,0x0,0x40,0x7fffffff,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x5afd675f,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x0,0x5afd675e,0x0,0x0,0x8000,0x0,0x0,0x0,0x0,0x0,0x4001,0xc0000,0x0,0x0,0x0,0x0,0x1000000,0x80000,0x0,0x0,0x0,0x0,0x0,0x1000000,0x1000000,0x0,0x5afd675e,0x5afd675e,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x0,0x5afd675e,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x5afd675e,0x5afd675e,0x0,0x0,0x0,0x5afd675e,0x0,0x5afd675e,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x5afd675e,0x5afd675e,0x0,0x5afd675e,0x0,0x5afd675e,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x5afd675e,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x0,0x0,0x0,0x0,0x0,0x5afde75f,0x10000100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x0,0x10000000,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x5afd675e,0x0,0x8080000,0x5afd675e,0x0,0x5afd675e,0x40000,0x0,0x8080000,0x8000000,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x0,0x0,0x0,0x0,0x14000000,0x14000000,0x0,0x14000000,0x14000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x5afd675e,0x0,0x0,0x8000,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x7fffffff,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x40000000,0x0,0x7fffffff,0x7fffffff,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x40,0x0,0x0,0x0,0x40,0x40,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x5afd675e,0x0,0x0,0x7fffffff,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x0,0x7fffffff,0x0,0x0,0x0,0x85029021,0x4afd4742,0x7fffffff,0x5afd675e,0x7efd7fdb,0xfc8001,0x0,};
40172 }
40173 private static void jj_la1_init_9() {
40174 jj_la1_9 = new int[] {0x400002c0,0x40000200,0x40000200,0x0,0xc0,0x0,0x0,0xfffdf371,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf371,0x0,0x0,0xffffff71,0x0,0x0,0x0,0xffffff71,0xffffff71,0xffffff71,0x0,0xffffff71,0xffffff71,0x0,0xffffff71,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0xffffff71,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf371,0x0,0xffffff71,0xffffff71,0x0,0x0,0x0,0x0,0xbffffd61,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffdf161,0x0,0x0,0xc00000,0x0,0x0,0x0,0x0,0xc3c0c00,0xf3fbc00,0x0,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x10000000,0x10000000,0x20000000,0x10000000,0x40000000,0x40000000,0x0,0xfffdf371,0xfffdf371,0x4,0x40000200,0x0,0xfffdf171,0xfffdf371,0x0,0xfffdf161,0x4,0x0,0x0,0xfffdf371,0xfffdf371,0xfffdf371,0xfffdf371,0x0,0x0,0x0,0xfffdf371,0x0,0xfffdf371,0x0,0xfffdf371,0x0,0x0,0x2,0x0,0xfffdf163,0x0,0xfffdf161,0xbffdf161,0x4,0xbffdf161,0x4,0xbffdf161,0xfffdf161,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x0,0xfffdf371,0x0,0xfffdf371,0x0,0xfffdf371,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc00000,0x0,0x0,0x0,0x0,0x0,0xbffffd61,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x0,0x0,0xfffdf161,0x0,0x0,0xfffdf161,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf161,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf161,0xfffdf161,0x0,0x0,0x0,0x0,0x0,0xfffdf161,0xfffdf161,0xfffdf161,0x0,0x0,0xbffdf161,0x0,0xfffdf161,0x20000000,0x0,0x0,0x0,0x100,0x0,0x0,0xfffdf161,0x0,0x0,0x0,0x1,0xffffff71,0x0,0x0,0x0,0x0,0xbffdf161,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbffdf161,0xbffdf161,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffdf371,0x0,0xffffff71,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x200,0x0,0x200,0x0,0x200,0x0,0xffffff71,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0xfffdf371,0x0,0x0,0xffffff71,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x0,0xffffff71,0x0,0x0,0x0,0x40000e0a,0xbfed7161,0xffffff71,0xbffdf161,0xbffffd71,0xff7ffc00,0x0,};
40175 }
40176 private static void jj_la1_init_10() {
40177 jj_la1_10 = new int[] {0xc7000000,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x0,0x0,0xff0000c7,0x0,0x0,0x400,0xff0004c7,0xff0084c7,0xff0084c7,0x2000,0xff0084c7,0xff0084c7,0x1000,0xff0084c7,0xff0084c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x0,0xff0000c7,0xff0004c7,0x0,0x0,0x0,0x0,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0xff0000c7,0x2000,0x1000,0x0,0x0,0x0,0x0,0x1,0x0,0x1,0x0,0x0,0x0,0x0,0x1,0x1,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0xff0084c7,0x0,0x0,0x0,0xff0084c7,0xff0084c7,0x0,0xff0004c7,0x0,0x0,0x0,0xff0084c7,0xff0084c7,0xff0084c7,0xff0084c7,0x0,0x0,0x0,0xff0084c7,0x0,0xff0084c7,0x0,0xff0084c7,0x0,0x0,0x0,0x0,0xff0004c7,0x0,0xff0004c7,0xff0000c7,0x0,0xff0000c7,0x0,0xff0000c7,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x2000,0xff0084c7,0x1000,0xff0084c7,0x8400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0004c7,0x2000,0x1000,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0xff0000c7,0xff0000c7,0x0,0x0,0xff0000c7,0x0,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0004c7,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0084c7,0x0,0xff0000c7,0xff0004c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff0000c7,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xe,0x0,0x0,0xc7000000,0x0,0x0,0x0,0xc7000000,0x10000000,0xff0000c7,0xc0,0xc0,0x20,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x28000000,0xe,0x0,0xff0084c7,0xe,0x0,0xff0000cf,0xe,0x0,0xff0000c7,0x6,0xc7000000,0x0,0xc7000000,0xff0000c7,0xc7000000,0x0,0xc7000000,0x300,0xff0000c7,0xff0000c7,0xff0000c7,0xff0000c7,0x1,0x0,};
40178 }
40179 private static void jj_la1_init_11() {
40180 jj_la1_11 = new int[] {0xfa002020,0x0,0x0,0x0,0xfa000000,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x4000000,0x0,0xffffffff,0x4000,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0xffffffff,0x4000,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x4004000,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x98000,0x0,0x0,0x0,0x0,0x98000,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x33ac,0x0,0x0,0x0,0x33ac,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x401,0xffffffff,0x0,0x401,0xffffffff,0x0,0x0,0xffffffff,0x0,0x33ac,0x0,0x33ac,0xffffffff,0x2020,0x138c,0x33ac,0x0,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0x4000000,0x0,};
40181 }
40182 private static void jj_la1_init_12() {
40183 jj_la1_12 = new int[] {0x1f,0x0,0x0,0x0,0x1f,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x18800,0x18800,0x1fc7ffff,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x6000,0x0,0x0,0x0,0x0,0x4000,0x0,0x4000,0x0,0x0,0x0,0x6000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x1fc7ffff,0x0,0x0,0x60000,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x100000,0x100000,0x300000,0x80000,0x0,0x80000,0x0,0x0,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x0,0x0,0x0,0x0,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x1fc7ffff,0x0,0x0,};
40184 }
40185 private static void jj_la1_init_13() {
40186 jj_la1_13 = new int[] {0x10,0x0,0x0,0x0,0x10,0x0,0x0,0x1630,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x1f010,0x0,0x0,0x10,0x1f010,0x1f010,0x1f010,0x0,0x1f010,0x1f010,0x0,0x1f010,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x1f010,0x1f010,0x0,0x0,0x0,0x0,0x1010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x600,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x1630,0x0,0x0,0x0,0x1630,0x1630,0x0,0x1630,0x0,0x0,0x10,0x1630,0x1630,0x1630,0x1630,0x10,0x0,0x0,0x1630,0x10,0x1630,0x10,0x1630,0x0,0x0,0x0,0x0,0x1630,0x0,0x1630,0x1010,0x0,0x1010,0x0,0x1010,0x1630,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x1630,0x0,0x1630,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1010,0x0,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x1410,0x1410,0x0,0x1410,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x1630,0x0,0x0,0x600,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x600,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x1630,0x0,0x0,0x0,0x0,0x0,0x1630,0x1630,0x1630,0x0,0x620,0x1010,0x0,0x1630,0x0,0x0,0x620,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x0,0x0,0x1f410,0x0,0x0,0x0,0x0,0x1010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1010,0x1010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x1f010,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1410,0x1410,0x0,0x0,0x0,0x0,0x0,0x1f010,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f410,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1630,0x0,0x0,0x1f010,0x0,0x10,0x1f010,0x0,0x0,0x0,0x0,0x1f010,0x0,0x0,0x0,0x0,0x0,0x1f010,0x1010,0x1010,0x1e000,0xe000,};
40187 }
40188 final private JJCalls[] jj_2_rtns = new JJCalls[84];
40189 private boolean jj_rescan = false;
40190 private int jj_gc = 0;
40191
40192
40193 public PLSQLParser(java.io.InputStream stream) {
40194 this(stream, null);
40195 }
40196
40197 public PLSQLParser(java.io.InputStream stream, String encoding) {
40198 try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
40199 token_source = new PLSQLParserTokenManager(jj_input_stream);
40200 token = new Token();
40201 token.next = jj_nt = token_source.getNextToken();
40202 jj_gen = 0;
40203 for (int i = 0; i < 458; i++) jj_la1[i] = -1;
40204 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40205 }
40206
40207
40208 public void ReInit(java.io.InputStream stream) {
40209 ReInit(stream, null);
40210 }
40211
40212 public void ReInit(java.io.InputStream stream, String encoding) {
40213 try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
40214 token_source.ReInit(jj_input_stream);
40215 token = new Token();
40216 token.next = jj_nt = token_source.getNextToken();
40217 jjtree.reset();
40218 jj_gen = 0;
40219 for (int i = 0; i < 458; i++) jj_la1[i] = -1;
40220 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40221 }
40222
40223
40224 public PLSQLParser(java.io.Reader stream) {
40225 jj_input_stream = new SimpleCharStream(stream, 1, 1);
40226 token_source = new PLSQLParserTokenManager(jj_input_stream);
40227 token = new Token();
40228 token.next = jj_nt = token_source.getNextToken();
40229 jj_gen = 0;
40230 for (int i = 0; i < 458; i++) jj_la1[i] = -1;
40231 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40232 }
40233
40234
40235 public void ReInit(java.io.Reader stream) {
40236 jj_input_stream.ReInit(stream, 1, 1);
40237 token_source.ReInit(jj_input_stream);
40238 token = new Token();
40239 token.next = jj_nt = token_source.getNextToken();
40240 jjtree.reset();
40241 jj_gen = 0;
40242 for (int i = 0; i < 458; i++) jj_la1[i] = -1;
40243 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40244 }
40245
40246
40247 public PLSQLParser(PLSQLParserTokenManager tm) {
40248 token_source = tm;
40249 token = new Token();
40250 token.next = jj_nt = token_source.getNextToken();
40251 jj_gen = 0;
40252 for (int i = 0; i < 458; i++) jj_la1[i] = -1;
40253 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40254 }
40255
40256
40257 public void ReInit(PLSQLParserTokenManager tm) {
40258 token_source = tm;
40259 token = new Token();
40260 token.next = jj_nt = token_source.getNextToken();
40261 jjtree.reset();
40262 jj_gen = 0;
40263 for (int i = 0; i < 458; i++) jj_la1[i] = -1;
40264 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
40265 }
40266
40267 private Token jj_consume_token(int kind) throws ParseException {
40268 Token oldToken = token;
40269 if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
40270 else jj_nt = jj_nt.next = token_source.getNextToken();
40271 if (token.kind == kind) {
40272 jj_gen++;
40273 if (++jj_gc > 100) {
40274 jj_gc = 0;
40275 for (int i = 0; i < jj_2_rtns.length; i++) {
40276 JJCalls c = jj_2_rtns[i];
40277 while (c != null) {
40278 if (c.gen < jj_gen) c.first = null;
40279 c = c.next;
40280 }
40281 }
40282 }
40283 return token;
40284 }
40285 jj_nt = token;
40286 token = oldToken;
40287 jj_kind = kind;
40288 throw generateParseException();
40289 }
40290
40291 static private final class LookaheadSuccess extends java.lang.Error { }
40292 final private LookaheadSuccess jj_ls = new LookaheadSuccess();
40293 private boolean jj_scan_token(int kind) {
40294 if (jj_scanpos == jj_lastpos) {
40295 jj_la--;
40296 if (jj_scanpos.next == null) {
40297 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
40298 } else {
40299 jj_lastpos = jj_scanpos = jj_scanpos.next;
40300 }
40301 } else {
40302 jj_scanpos = jj_scanpos.next;
40303 }
40304 if (jj_rescan) {
40305 int i = 0; Token tok = token;
40306 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
40307 if (tok != null) jj_add_error_token(kind, i);
40308 }
40309 if (jj_scanpos.kind != kind) return true;
40310 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
40311 return false;
40312 }
40313
40314
40315
40316 final public Token getNextToken() {
40317 if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
40318 else jj_nt = jj_nt.next = token_source.getNextToken();
40319 jj_gen++;
40320 return token;
40321 }
40322
40323
40324 final public Token getToken(int index) {
40325 Token t = token;
40326 for (int i = 0; i < index; i++) {
40327 if (t.next != null) t = t.next;
40328 else t = t.next = token_source.getNextToken();
40329 }
40330 return t;
40331 }
40332
40333 private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
40334 private int[] jj_expentry;
40335 private int jj_kind = -1;
40336 private int[] jj_lasttokens = new int[100];
40337 private int jj_endpos;
40338
40339 private void jj_add_error_token(int kind, int pos) {
40340 if (pos >= 100) return;
40341 if (pos == jj_endpos + 1) {
40342 jj_lasttokens[jj_endpos++] = kind;
40343 } else if (jj_endpos != 0) {
40344 jj_expentry = new int[jj_endpos];
40345 for (int i = 0; i < jj_endpos; i++) {
40346 jj_expentry[i] = jj_lasttokens[i];
40347 }
40348 jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
40349 int[] oldentry = (int[])(it.next());
40350 if (oldentry.length == jj_expentry.length) {
40351 for (int i = 0; i < jj_expentry.length; i++) {
40352 if (oldentry[i] != jj_expentry[i]) {
40353 continue jj_entries_loop;
40354 }
40355 }
40356 jj_expentries.add(jj_expentry);
40357 break jj_entries_loop;
40358 }
40359 }
40360 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
40361 }
40362 }
40363
40364
40365 public ParseException generateParseException() {
40366 jj_expentries.clear();
40367 boolean[] la1tokens = new boolean[434];
40368 if (jj_kind >= 0) {
40369 la1tokens[jj_kind] = true;
40370 jj_kind = -1;
40371 }
40372 for (int i = 0; i < 458; i++) {
40373 if (jj_la1[i] == jj_gen) {
40374 for (int j = 0; j < 32; j++) {
40375 if ((jj_la1_0[i] & (1<<j)) != 0) {
40376 la1tokens[j] = true;
40377 }
40378 if ((jj_la1_1[i] & (1<<j)) != 0) {
40379 la1tokens[32+j] = true;
40380 }
40381 if ((jj_la1_2[i] & (1<<j)) != 0) {
40382 la1tokens[64+j] = true;
40383 }
40384 if ((jj_la1_3[i] & (1<<j)) != 0) {
40385 la1tokens[96+j] = true;
40386 }
40387 if ((jj_la1_4[i] & (1<<j)) != 0) {
40388 la1tokens[128+j] = true;
40389 }
40390 if ((jj_la1_5[i] & (1<<j)) != 0) {
40391 la1tokens[160+j] = true;
40392 }
40393 if ((jj_la1_6[i] & (1<<j)) != 0) {
40394 la1tokens[192+j] = true;
40395 }
40396 if ((jj_la1_7[i] & (1<<j)) != 0) {
40397 la1tokens[224+j] = true;
40398 }
40399 if ((jj_la1_8[i] & (1<<j)) != 0) {
40400 la1tokens[256+j] = true;
40401 }
40402 if ((jj_la1_9[i] & (1<<j)) != 0) {
40403 la1tokens[288+j] = true;
40404 }
40405 if ((jj_la1_10[i] & (1<<j)) != 0) {
40406 la1tokens[320+j] = true;
40407 }
40408 if ((jj_la1_11[i] & (1<<j)) != 0) {
40409 la1tokens[352+j] = true;
40410 }
40411 if ((jj_la1_12[i] & (1<<j)) != 0) {
40412 la1tokens[384+j] = true;
40413 }
40414 if ((jj_la1_13[i] & (1<<j)) != 0) {
40415 la1tokens[416+j] = true;
40416 }
40417 }
40418 }
40419 }
40420 for (int i = 0; i < 434; i++) {
40421 if (la1tokens[i]) {
40422 jj_expentry = new int[1];
40423 jj_expentry[0] = i;
40424 jj_expentries.add(jj_expentry);
40425 }
40426 }
40427 jj_endpos = 0;
40428 jj_rescan_token();
40429 jj_add_error_token(0, 0);
40430 int[][] exptokseq = new int[jj_expentries.size()][];
40431 for (int i = 0; i < jj_expentries.size(); i++) {
40432 exptokseq[i] = jj_expentries.get(i);
40433 }
40434 return new ParseException(token, exptokseq, tokenImage);
40435 }
40436
40437
40438 final public void enable_tracing() {
40439 }
40440
40441
40442 final public void disable_tracing() {
40443 }
40444
40445 private void jj_rescan_token() {
40446 jj_rescan = true;
40447 for (int i = 0; i < 84; i++) {
40448 try {
40449 JJCalls p = jj_2_rtns[i];
40450 do {
40451 if (p.gen > jj_gen) {
40452 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
40453 switch (i) {
40454 case 0: jj_3_1(); break;
40455 case 1: jj_3_2(); break;
40456 case 2: jj_3_3(); break;
40457 case 3: jj_3_4(); break;
40458 case 4: jj_3_5(); break;
40459 case 5: jj_3_6(); break;
40460 case 6: jj_3_7(); break;
40461 case 7: jj_3_8(); break;
40462 case 8: jj_3_9(); break;
40463 case 9: jj_3_10(); break;
40464 case 10: jj_3_11(); break;
40465 case 11: jj_3_12(); break;
40466 case 12: jj_3_13(); break;
40467 case 13: jj_3_14(); break;
40468 case 14: jj_3_15(); break;
40469 case 15: jj_3_16(); break;
40470 case 16: jj_3_17(); break;
40471 case 17: jj_3_18(); break;
40472 case 18: jj_3_19(); break;
40473 case 19: jj_3_20(); break;
40474 case 20: jj_3_21(); break;
40475 case 21: jj_3_22(); break;
40476 case 22: jj_3_23(); break;
40477 case 23: jj_3_24(); break;
40478 case 24: jj_3_25(); break;
40479 case 25: jj_3_26(); break;
40480 case 26: jj_3_27(); break;
40481 case 27: jj_3_28(); break;
40482 case 28: jj_3_29(); break;
40483 case 29: jj_3_30(); break;
40484 case 30: jj_3_31(); break;
40485 case 31: jj_3_32(); break;
40486 case 32: jj_3_33(); break;
40487 case 33: jj_3_34(); break;
40488 case 34: jj_3_35(); break;
40489 case 35: jj_3_36(); break;
40490 case 36: jj_3_37(); break;
40491 case 37: jj_3_38(); break;
40492 case 38: jj_3_39(); break;
40493 case 39: jj_3_40(); break;
40494 case 40: jj_3_41(); break;
40495 case 41: jj_3_42(); break;
40496 case 42: jj_3_43(); break;
40497 case 43: jj_3_44(); break;
40498 case 44: jj_3_45(); break;
40499 case 45: jj_3_46(); break;
40500 case 46: jj_3_47(); break;
40501 case 47: jj_3_48(); break;
40502 case 48: jj_3_49(); break;
40503 case 49: jj_3_50(); break;
40504 case 50: jj_3_51(); break;
40505 case 51: jj_3_52(); break;
40506 case 52: jj_3_53(); break;
40507 case 53: jj_3_54(); break;
40508 case 54: jj_3_55(); break;
40509 case 55: jj_3_56(); break;
40510 case 56: jj_3_57(); break;
40511 case 57: jj_3_58(); break;
40512 case 58: jj_3_59(); break;
40513 case 59: jj_3_60(); break;
40514 case 60: jj_3_61(); break;
40515 case 61: jj_3_62(); break;
40516 case 62: jj_3_63(); break;
40517 case 63: jj_3_64(); break;
40518 case 64: jj_3_65(); break;
40519 case 65: jj_3_66(); break;
40520 case 66: jj_3_67(); break;
40521 case 67: jj_3_68(); break;
40522 case 68: jj_3_69(); break;
40523 case 69: jj_3_70(); break;
40524 case 70: jj_3_71(); break;
40525 case 71: jj_3_72(); break;
40526 case 72: jj_3_73(); break;
40527 case 73: jj_3_74(); break;
40528 case 74: jj_3_75(); break;
40529 case 75: jj_3_76(); break;
40530 case 76: jj_3_77(); break;
40531 case 77: jj_3_78(); break;
40532 case 78: jj_3_79(); break;
40533 case 79: jj_3_80(); break;
40534 case 80: jj_3_81(); break;
40535 case 81: jj_3_82(); break;
40536 case 82: jj_3_83(); break;
40537 case 83: jj_3_84(); break;
40538 }
40539 }
40540 p = p.next;
40541 } while (p != null);
40542 } catch(LookaheadSuccess ls) { }
40543 }
40544 jj_rescan = false;
40545 }
40546
40547 private void jj_save(int index, int xla) {
40548 JJCalls p = jj_2_rtns[index];
40549 while (p.gen > jj_gen) {
40550 if (p.next == null) { p = p.next = new JJCalls(); break; }
40551 p = p.next;
40552 }
40553 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
40554 }
40555
40556 static final class JJCalls {
40557 int gen;
40558 Token first;
40559 int arg;
40560 JJCalls next;
40561 }
40562
40563 }